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

package/commands/connect/notifications/index.js

@@ -0,0 +1,57 @@
+import * as api from '../../../lib/connect/api.js'
+import cli from '@heroku/heroku-cli-util'
+import { Command, flags } from '@heroku-cli/command'
+
+export function formatDate (date) {
+  if (!date) return ''
+  const d = new Date(date)
+  return d.toLocaleString('en-US', {
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit'
+  })
+}
+
+export function truncateMessage (message, maxLength = 50) {
+  if (!message) return ''
+  if (message.length <= maxLength) return message
+  return message.substring(0, maxLength - 3) + '...'
+}
+
+export default class Notifications extends Command {
+  static description = 'Return the unacknowledged notifications'
+
+  static flags = {
+    app: flags.app({ required: true }),
+    after: flags.string({ description: 'start date for notifications' }),
+    before: flags.string({ description: 'end date for notifications' }),
+    'event-type': flags.string({ description: 'type of event to filter by' }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { args, flags } = await this.parse(Notifications)
+    const context = { app: flags.app, flags, args, auth: { password: this.heroku.auth } }
+
+    const connection = await api.withConnection(context, this.heroku)
+    context.region = connection.region_url
+
+    const params = {
+      page_size: 1000,
+      after: context.flags.after,
+      before: context.flags.before,
+      event_type: context.flags['event-type']
+    }
+
+    const response = await api.request(context, 'GET', '/api/v3/connections/' + connection.id + '/notifications', null, params)
+    cli.table(response.data.results, {
+      columns: [
+        { key: 'event_type', label: 'Event Type' },
+        { key: 'message', label: 'Message', format: (message) => truncateMessage(message, 50) },
+        { key: 'created_at', label: 'Created At (MM/DD/YYYY HH:MM AM/PM)', format: formatDate }
+      ]
+    })
+  }
+}

package/commands/connect/pause.js

@@ -1,24 +1,29 @@
-'use strict'
-const api = require('../../lib/connect/api.js')
-const cli = require('@heroku/heroku-cli-util')
-const co = require('co')
+import { Command, flags } from '@heroku-cli/command'
+import cli from '@heroku/heroku-cli-util'
+import * as api from '../../lib/connect/api.js'
 
-module.exports = {
-  topic: 'connect',
-  command: 'pause',
-  description: 'Pause a connection',
-  help: 'Pauses an active connection',
-  flags: [
-    { name: 'resource', description: 'specific connection resource name', hasValue: true }
-  ],
-  needsApp: true,
-  needsAuth: true,
-  run: cli.command(co.wrap(function * (context, heroku) {
-    yield cli.action('pausing connection', co(function * () {
-      const connection = yield api.withConnection(context, heroku)
+export default class ConnectPause extends Command {
+  static description = 'Pause a connection'
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { flags } = await this.parse(ConnectPause)
+    const context = {
+      app: flags.app,
+      flags,
+      args: {},
+      auth: { password: this.heroku.auth }
+    }
+
+    await cli.action('pausing connection', (async function () {
+      const connection = await api.withConnection(context, this.heroku)
       context.region = connection.region_url
       const url = '/api/v3/connections/' + connection.id + '/actions/pause'
-      yield api.request(context, 'POST', url)
-    }))
-  }))
+      await api.request(context, 'POST', url)
+    }.bind(this))())
+  }
 }

package/commands/connect/recover.js

@@ -1,25 +1,31 @@
-'use strict'
-const api = require('../../lib/connect/api.js')
-const cli = require('@heroku/heroku-cli-util')
-const co = require('co')
+import { Command, flags } from '@heroku-cli/command'
+import cli from '@heroku/heroku-cli-util'
+import * as api from '../../lib/connect/api.js'
 
-module.exports = {
-  topic: 'connect',
-  command: 'recover',
-  aliases: ['connect:restart'],
-  description: 'Recover a connection',
-  help: 'Clears errors and attempts to resume sync operations',
-  flags: [
-    { name: 'resource', description: 'specific connection resource name', hasValue: true }
-  ],
-  needsApp: true,
-  needsAuth: true,
-  run: cli.command(co.wrap(function * (context, heroku) {
-    yield cli.action('recovering connection', co(function * () {
-      const connection = yield api.withConnection(context, heroku)
+export default class ConnectRecover extends Command {
+  static description = 'Recover a connection'
+
+  static aliases = ['connect:restart']
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { flags } = await this.parse(ConnectRecover)
+    const context = {
+      app: flags.app,
+      flags,
+      args: {},
+      auth: { password: this.heroku.auth }
+    }
+
+    await cli.action('recovering connection', (async function () {
+      const connection = await api.withConnection(context, this.heroku)
       context.region = connection.region_url
       const url = '/api/v3/connections/' + connection.id + '/actions/restart'
-      yield api.request(context, 'POST', url)
-    }))
-  }))
+      await api.request(context, 'POST', url)
+    }.bind(this))())
+  }
 }

package/commands/connect/resume.js

@@ -1,24 +1,29 @@
-'use strict'
-const api = require('../../lib/connect/api.js')
-const cli = require('@heroku/heroku-cli-util')
-const co = require('co')
+import { Command, flags } from '@heroku-cli/command'
+import cli from '@heroku/heroku-cli-util'
+import * as api from '../../lib/connect/api.js'
 
-module.exports = {
-  topic: 'connect',
-  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)
+export default class ConnectResume 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(ConnectResume)
+    const context = {
+      app: flags.app,
+      flags,
+      args: {},
+      auth: { password: this.heroku.auth }
+    }
+
+    await cli.action('resuming connection', (async function () {
+      const connection = await api.withConnection(context, this.heroku)
       context.region = connection.region_url
       const url = '/api/v3/connections/' + connection.id + '/actions/resume'
-      yield api.request(context, 'POST', url)
-    }))
-  }))
+      await api.request(context, 'POST', url)
+    }.bind(this))())
+  }
 }

package/commands/connect/sf/auth.js

@@ -0,0 +1,75 @@
+import * as api from '../../../lib/connect/api.js'
+import cli from '@heroku/heroku-cli-util'
+import http from 'http'
+import { Command, flags } from '@heroku-cli/command'
+
+const LOCAL_PORT = 18000
+
+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) {
+      // Notify the user that the the authorization is complete
+      response.writeHead(200, { 'Content-Type': 'text/html' })
+      const res = '<html><body><h3>Authorization complete</h3><p>You may close this window and return to the terminal to continue.</p></body></html>'
+      response.end(res)
+
+      // Shut down the server so the command can exit
+      request.socket.destroy()
+      this.close()
+
+      // Return control to the main command
+      resolve()
+    }).listen(LOCAL_PORT)
+  })
+}
+
+export default class SfAuth extends Command {
+  static description = 'Authorize access to Salesforce for your connection'
+
+  static callbackServer = callbackServer
+
+  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 { args, flags } = await this.parse(SfAuth)
+    const context = { app: flags.app, flags, args, auth: { password: this.heroku.auth } }
+
+    let redir
+    await cli.action('fetching authorizing URL', (async function () {
+      const connection = await api.withConnection(context, this.heroku)
+      context.region = connection.region_url
+
+      const url = `/api/v3/connections/${connection.id}/authorize_url`
+      const args = {
+        environment: 'production',
+        // Redirect to the local server created in callbackServer(), so the CLI
+        // can respond immediately after successful authorization
+        next: `http://localhost:${LOCAL_PORT}`
+      }
+
+      if (context.flags.environment) {
+        args.environment = context.flags.environment
+      }
+
+      if (context.flags.environment === 'custom' && context.flags.domain) {
+        args.domain = context.flags.domain
+      }
+
+      const response = await api.request(context, 'POST', url, args)
+      redir = response.data.redirect
+
+      await cli.open(redir)
+    }.bind(this))())
+
+    cli.log("\nIf your browser doesn't open, please copy the following URL to proceed:\n" + redir + '\n')
+
+    await cli.action('waiting for authorization', SfAuth.callbackServer())
+  }
+}

package/commands/connect/state.js

@@ -1,34 +1,37 @@
-'use strict'
-const api = require('../../lib/connect/api.js')
-const cli = require('@heroku/heroku-cli-util')
-const co = require('co')
+import { Command, flags } from '@heroku-cli/command'
+import cli from '@heroku/heroku-cli-util'
+import * as api from '../../lib/connect/api.js'
 
-function * run (context, heroku) {
-  const connections = yield api.withUserConnections(context, context.app, context.flags, heroku)
+export default class ConnectState extends Command {
+  static description = 'return the connection(s) state'
 
-  if (context.flags.json) {
-    cli.styledJSON(connections)
-  } else {
-    cli.table(connections, {
-      columns: [
-        { key: 'db_key', label: 'Database' },
-        { key: 'schema_name', label: 'Schema' },
-        { key: 'state', label: 'State' }
-      ]
-    })
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' }),
+    json: flags.boolean({ description: 'print output as json' })
   }
-}
 
-module.exports = {
-  topic: 'connect',
-  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))
+  async run () {
+    const { flags } = await this.parse(ConnectState)
+    const context = {
+      app: flags.app,
+      flags,
+      args: {},
+      auth: { password: this.heroku.auth }
+    }
+
+    const connections = await api.withUserConnections(context, flags.app, flags, this.heroku)
+
+    if (flags.json) {
+      cli.styledJSON(connections)
+    } else {
+      cli.table(connections, {
+        columns: [
+          { key: 'db_key', label: 'Database' },
+          { key: 'schema_name', label: 'Schema' },
+          { key: 'state', label: 'State' }
+        ]
+      })
+    }
+  }
 }

package/commands/connect/write-errors.js

@@ -1,27 +1,28 @@
-'use strict'
-const api = require('../../lib/connect/api.js')
-const cli = require('@heroku/heroku-cli-util')
+import { Command, flags } from '@heroku-cli/command'
+import * as api from '../../lib/connect/api.js'
 
-module.exports = {
-  topic: 'connect',
-  command: 'write-errors',
-  description: 'Display the last 24 hours of write errors on this connection',
-  examples: [
+export default class ConnectWriteErrors extends Command {
+  static description = 'Display the last 24 hours of write errors on this connection'
+
+  static examples = [
     '$ heroku connect:write-errors -a myapp --resource herokuconnect-twisted-123'
-  ],
-  flags: [
-    {
-      name: 'resource',
-      description: 'specific connection resource name',
-      hasValue: true
-    },
-    {
-      name: 'json',
-      description: 'print errors as styled JSON',
-      hasValue: false
+  ]
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' }),
+    json: flags.boolean({ description: 'print errors as styled JSON' })
+  }
+
+  async run () {
+    const { flags } = await this.parse(ConnectWriteErrors)
+    const context = {
+      app: flags.app,
+      flags,
+      args: {},
+      auth: { password: this.heroku.auth }
     }
-  ],
-  needsApp: true,
-  needsAuth: true,
-  run: cli.command(api.getWriteErrors)
+
+    await api.getWriteErrors(context, this.heroku)
+  }
 }

package/commands/connect-events/db/set.js

@@ -0,0 +1,72 @@
+import * as api from '../../../lib/connect/api.js'
+import { Command, flags } from '@heroku-cli/command'
+import cli from '@heroku/heroku-cli-util'
+import inquirer from 'inquirer'
+
+async function fetchKeys (appName, context) {
+  const url = `/api/v3/apps/${appName}`
+  const response = await api.request(context, 'GET', url)
+  const keys = []
+  response.data.db_keys.forEach(function (key) {
+    keys.push({
+      name: `${key.name} (${key.addon.plan})`,
+      value: key.name
+    })
+  })
+  return keys
+}
+
+export default class ConnectEventsDbSet extends Command {
+  static description = 'Set database parameters'
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' }),
+    db: flags.string({ description: 'Database config var name' }),
+    schema: flags.string({ description: 'Database schema name' })
+  }
+
+  async run () {
+    const { flags } = await this.parse(ConnectEventsDbSet)
+    const context = {
+      app: flags.app,
+      flags,
+      auth: { password: this.heroku.auth }
+    }
+
+    const data = {
+      db_key: flags.db,
+      schema_name: flags.schema
+    }
+
+    const connection = await api.withConnection(context, this.heroku, api.ADDON_TYPE_EVENTS)
+    context.region = connection.region_url
+
+    const answers = await inquirer.prompt([
+      {
+        name: 'db_key',
+        type: 'list',
+        message: "Select the config var that points to the database you'd like to use",
+        choices: await fetchKeys(connection.app_name, context),
+        when: !flags.db
+      },
+      {
+        name: 'schema_name',
+        message: "Enter a schema name you'd like to use for the conneted data",
+        default: flags.schema || 'salesforce',
+        when: !flags.schema
+      }
+    ])
+
+    for (const key in answers) {
+      data[key] = answers[key]
+    }
+
+    await cli.action('setting database parameters', (async function () {
+      const url = `/api/v3/kafka-connections/${connection.id}`
+      await api.request(context, 'PUT', url, data)
+    })())
+
+    cli.styledHash(data)
+  }
+}

package/commands/connect-events/info.js

@@ -1,29 +1,32 @@
-'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'
+
+export default class ConnectEventsInfo extends Command {
+  static description = 'display connection information'
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' }),
+    'check-for-new': flags.boolean({ char: 'c', description: 'check for access to any new connections' })
+  }
+
+  async run () {
+    const { flags } = await this.parse(ConnectEventsInfo)
+    const context = {
+      app: flags.app,
+      flags,
+      auth: { password: this.heroku.auth }
+    }
 
-module.exports = {
-  topic: 'connect-events',
-  command: 'info',
-  default: false,
-  description: 'display connection information',
-  help: 'display connection information',
-  flags: [
-    { name: 'resource', description: 'specific connection resource name', hasValue: true },
-    { name: 'check-for-new', char: 'c', description: 'check for access to any new connections', hasValue: false }
-  ],
-  needsApp: true,
-  needsAuth: true,
-  run: cli.command(co.wrap(function * (context, heroku) {
     let connections
 
-    if (context.flags['check-for-new']) {
-      connections = yield api.requestAppAccess(context, context.app, context.flags, true, heroku, api.ADDON_TYPE_EVENTS)
+    if (flags['check-for-new']) {
+      connections = await api.requestAppAccess(context, flags.app, flags, true, this.heroku, api.ADDON_TYPE_EVENTS)
     } else {
-      connections = yield api.withUserConnections(context, context.app, context.flags, true, heroku, api.ADDON_TYPE_EVENTS)
+      connections = await api.withUserConnections(context, flags.app, flags, true, this.heroku, api.ADDON_TYPE_EVENTS)
       if (connections.length === 0) {
-        connections = yield api.requestAppAcess(context, context.app, context.flags, true, heroku, api.ADDON_TYPE_EVENTS)
+        connections = await api.requestAppAcess(context, flags.app, flags, true, this.heroku, api.ADDON_TYPE_EVENTS)
       }
     }
 
@@ -32,9 +35,9 @@ module.exports = {
       cli.error('No connection found. You may need to use addons:open to make it accessible to the CLI.')
       cli.error('')
       cli.error('For Example:')
-      cli.error(`heroku addons:open ${instanceName} -a ${context.app}`)
+      cli.error(`heroku addons:open ${instanceName} -a ${flags.app}`)
     } else {
-      connections = yield api.withStreams(context, connections)
+      connections = await api.withStreams(context, connections)
       connections.forEach(function (connection) {
         cli.styledHeader(`Connection [${connection.id}] / ${connection.resource_name} (${connection.state})`)
         cli.log()
@@ -53,5 +56,5 @@ module.exports = {
         cli.log()
       })
     }
-  }))
+  }
 }

package/commands/connect-events/pause.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: 'pause',
-  description: 'Pause a connection',
-  help: 'Pauses an active connection',
-  flags: [
-    { name: 'resource', description: 'specific connection resource name', hasValue: true }
-  ],
-  needsApp: true,
-  needsAuth: true,
-  run: cli.command(co.wrap(function * (context, heroku) {
-    yield cli.action('pausing connection', co(function * () {
-      const connection = yield api.withConnection(context, heroku, api.ADDON_TYPE_EVENTS)
+export default class ConnectEventsPause extends Command {
+  static description = 'Pause a connection'
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { flags } = await this.parse(ConnectEventsPause)
+    const context = {
+      app: flags.app,
+      flags,
+      auth: { password: this.heroku.auth }
+    }
+
+    await cli.action('pausing 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/pause`
-      yield api.request(context, 'POST', url)
-    }))
-  }))
+      await api.request(context, 'POST', url)
+    }.bind(this))())
+  }
 }

package/commands/connect-events/recover.js

@@ -1,25 +1,30 @@
-'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: 'recover',
-  aliases: ['connect:restart'],
-  description: 'Recover a connection',
-  help: 'Clears errors and attempts to resume sync operations',
-  flags: [
-    { name: 'resource', description: 'specific connection resource name', hasValue: true }
-  ],
-  needsApp: true,
-  needsAuth: true,
-  run: cli.command(co.wrap(function * (context, heroku) {
-    yield cli.action('recovering connection', co(function * () {
-      const connection = yield api.withConnection(context, heroku, api.ADDON_TYPE_EVENTS)
+export default class ConnectEventsRecover extends Command {
+  static description = 'Recover a connection'
+
+  static aliases = ['connect:restart']
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { flags } = await this.parse(ConnectEventsRecover)
+    const context = {
+      app: flags.app,
+      flags,
+      auth: { password: this.heroku.auth }
+    }
+
+    await cli.action('recovering 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/recover`
-      yield api.request(context, 'POST', url)
-    }))
-  }))
+      await api.request(context, 'POST', url)
+    }.bind(this))())
+  }
 }