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

package/README.md

@@ -16,19 +16,21 @@ $ heroku help connect
 ## Commands
 
 ```text
-heroku connect:db:set                  - Set database parameters
-heroku connect:diagnose                - Display diagnostic information about a connection
-heroku connect:export                  - Export a mapping configuration JSON file
-heroku connect:import FILE             - Import a mapping configuration JSON file
-heroku connect:info                    - Display connection information 
-heroku connect:mapping:state MAPPING   - Return the state of a mapping
-heroku connect:mapping:delete MAPPING  - Delete an existing mapping
-heroku connect:mapping:reload MAPPING  - Reload a mapping's data from Salesforce
-heroku connect:pause                   - Pause a connection
-heroku connect:resume                  - Resume a connection
-heroku connect:restart                 - Restart a connection
-heroku connect:sf:auth                 - Authenticate a connection to Salesforce
-heroku connect:state                   - Return the state flag for a single connection
+heroku connect:db:set                     - Set database parameters
+heroku connect:diagnose                   - Display diagnostic information about a connection
+heroku connect:export                     - Export a mapping configuration JSON file
+heroku connect:import FILE                - Import a mapping configuration JSON file
+heroku connect:info                       - Display connection information 
+heroku connect:mapping:state MAPPING      - Return the state of a mapping
+heroku connect:mapping:delete MAPPING     - Delete an existing mapping
+heroku connect:mapping:reload MAPPING     - Reload a mapping's data from Salesforce
+heroku connect:notifications              - List unacknowledged notifications
+heroku connect:notifications:acknowledge  - Acknowledge pending notifications
+heroku connect:pause                      - Pause a connection
+heroku connect:resume                     - Resume a connection
+heroku connect:restart                    - Restart a connection
+heroku connect:sf:auth                    - Authenticate a connection to Salesforce
+heroku connect:state                      - Return the state flag for a single connection
 ```
 
 ## Examples

package/commands/connect/db/set.js

@@ -0,0 +1,69 @@
+import * as api from '../../../lib/connect/api.js'
+import cli from '@heroku/heroku-cli-util'
+import inquirer from 'inquirer'
+import { Command, flags } from '@heroku-cli/command'
+
+async function fetchKeys (appName, context) {
+  const url = '/api/v3/apps/' + appName
+  const response = await api.request(context, 'GET', url)
+  const keys = []// new Array(response.json.db_keys.length);
+  response.data.db_keys.forEach(function (key) {
+    const plan = (key.addon ? key.addon.plan : null) || 'Unknown Plan'
+    keys.push({
+      name: `${key.name} (${plan})`,
+      value: key.name
+    })
+  })
+  return keys
+}
+
+export default class DbSet 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 { args, flags } = await this.parse(DbSet)
+    const context = { app: flags.app, flags, args, auth: { password: this.heroku.auth } }
+
+    const data = {
+      db_key: context.flags.db,
+      schema_name: context.flags.schema
+    }
+
+    const connection = await api.withConnection(context, this.heroku)
+    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: !context.flags.db
+      },
+      {
+        name: 'schema_name',
+        message: "Enter a schema name you'd like to use for the conneted data",
+        default: context.flags.schema || 'salesforce',
+        when: !context.flags.schema
+      }
+    ])
+
+    for (const key in answers) {
+      data[key] = answers[key]
+    }
+
+    await cli.action('setting database parameters', (async function () {
+      const url = '/api/v3/connections/' + connection.id
+      await api.request(context, 'PATCH', url, data)
+    })())
+
+    cli.styledHash(data)
+  }
+}

package/commands/connect/diagnose.js

@@ -1,7 +1,6 @@
-'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 displayResults (results, flags) {
   results.errors.forEach(displayResult('RED', 'red'))
@@ -38,26 +37,32 @@ function timeout (duration) {
   })
 }
 
-module.exports = {
-  topic: 'connect',
-  command: 'diagnose',
-  description: 'Display diagnostic information about a connection',
-  help: 'Checks a connection for common configuration errors. ',
-  flags: [
-    { name: 'resource', description: 'specific connection resource name', hasValue: true },
-    { name: 'verbose', char: 'v', description: 'display passed and skipped check information as well' }
-  ],
-  needsApp: true,
-  needsAuth: true,
-  run: cli.command(co.wrap(function * (context, heroku) {
+export default class ConnectDiagnose extends Command {
+  static description = 'Display diagnostic information about a connection'
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' }),
+    verbose: flags.boolean({ char: 'v', description: 'display passed and skipped check information as well' })
+  }
+
+  async run () {
+    const { flags } = await this.parse(ConnectDiagnose)
+    const context = {
+      app: flags.app,
+      flags,
+      args: {},
+      auth: { password: this.heroku.auth }
+    }
+
     let mappingResults
     let didDisplayAnything = false
-    const connection = yield api.withConnection(context, heroku)
+    const connection = await api.withConnection(context, this.heroku)
     context.region = connection.region_url
-    const results = yield cli.action('Diagnosing connection', co(function * () {
+    const results = await cli.action('Diagnosing connection', (async function () {
       const url = '/api/v3/connections/' + connection.id + '/validations'
       try {
-        const { data: { result_url: resultUrl } } = yield api.request(context, 'POST', url)
+        const { data: { result_url: resultUrl } } = await api.request(context, 'POST', url)
 
         let i = 0
 
@@ -66,7 +71,7 @@ module.exports = {
             cli.error('There was an issue retrieving validations')
             break
           }
-          const response = yield api.request(context, 'GET', resultUrl)
+          const response = await api.request(context, 'GET', resultUrl)
 
           if (response.status === 200) {
             return response.data
@@ -74,35 +79,35 @@ module.exports = {
 
           i++
 
-          yield timeout(500)
+          await timeout(500)
         }
       } catch (err) {
         cli.error(err)
       }
-    }))
+    })())
 
     cli.log() // Blank line to separate each section
     cli.styledHeader(`Connection: ${connection.name || connection.internal_name}`)
-    if (shouldDisplay(results, context.flags)) {
+    if (shouldDisplay(results, flags)) {
       didDisplayAnything = true
-      displayResults(results, context.flags)
+      displayResults(results, flags)
     }
 
     for (const objectName in results.mappings) {
       mappingResults = results.mappings[objectName]
-      if (shouldDisplay(mappingResults, context.flags)) {
+      if (shouldDisplay(mappingResults, flags)) {
         didDisplayAnything = true
         cli.log() // Blank line to separate each section
         cli.styledHeader(objectName)
-        displayResults(mappingResults, context.flags)
+        displayResults(mappingResults, flags)
       }
     }
 
-    if (!didDisplayAnything && !context.flags.verbose) {
+    if (!didDisplayAnything && !flags.verbose) {
       cli.log(cli.color.green('Everything appears to be fine'))
     }
-  })),
-
-  // Additional exports for code sharing
-  displayResults
+  }
 }
+
+// Additional exports for code sharing
+export { displayResults }

package/commands/connect/export.js

@@ -1,35 +1,40 @@
-'use strict'
-const api = require('../../lib/connect/api.js')
-const cli = require('@heroku/heroku-cli-util')
-const co = require('co')
-const fs = require('fs')
+import { Command, flags } from '@heroku-cli/command'
+import cli from '@heroku/heroku-cli-util'
+import * as api from '../../lib/connect/api.js'
+import fs from 'fs'
+
+export default class ConnectExport extends Command {
+  static description = 'Export configuration from a connection'
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { flags } = await this.parse(ConnectExport)
+    const context = {
+      app: flags.app,
+      flags,
+      args: {},
+      auth: { password: this.heroku.auth }
+    }
 
-module.exports = {
-  topic: 'connect',
-  command: 'export',
-  description: 'Export configuration from a connection',
-  help: 'Exports the mapping configuration from a connection as a json file',
-  flags: [
-    { name: 'resource', description: 'specific connection resource name', hasValue: true }
-  ],
-  needsApp: true,
-  needsAuth: true,
-  run: cli.command(co.wrap(function * (context, heroku) {
     let connection, response
 
-    yield cli.action('fetching configuration', co(function * () {
-      connection = yield api.withConnection(context, heroku)
+    await cli.action('fetching configuration', (async function () {
+      connection = await api.withConnection(context, this.heroku)
       context.region = connection.region_url
       const url = '/api/v3/connections/' + connection.id + '/actions/export'
-      response = yield api.request(context, 'GET', url)
-    }))
+      response = await api.request(context, 'GET', url)
+    }.bind(this))())
 
     const fName = connection.app_name + '-' + (connection.resource_name || '') + '.json'
 
-    yield cli.action('writing configuration to file', {
+    await cli.action('writing configuration to file', {
       success: fName
-    }, co(function * () {
+    }, (async function () {
       fs.writeFileSync(fName, JSON.stringify(response.data, null, 4))
-    }))
-  }))
+    })())
+  }
 }

package/commands/connect/import.js

@@ -1,30 +1,37 @@
-'use strict'
-const api = require('../../lib/connect/api.js')
-const cli = require('@heroku/heroku-cli-util')
-const co = require('co')
-const fs = require('fs')
+import { Command, flags } from '@heroku-cli/command'
+import { Args } from '@oclif/core'
+import cli from '@heroku/heroku-cli-util'
+import * as api from '../../lib/connect/api.js'
+import fs from 'fs'
 
-module.exports = {
-  topic: 'connect',
-  command: 'import',
-  description: 'Import configuration from an export file',
-  help: 'Imports the mapping configuration from a json export file',
-  args: [
-    { name: 'file', desciption: 'JSON export file name' }
-  ],
-  flags: [
-    { name: 'resource', description: 'specific connection resource name', hasValue: true }
-  ],
-  needsApp: true,
-  needsAuth: true,
-  run: cli.command(co.wrap(function * (context, heroku) {
-    const fName = context.args.file
-    yield cli.action(`uploading ${fName}`, co(function * () {
-      const connection = yield api.withConnection(context, heroku)
+export default class ConnectImport extends Command {
+  static description = 'Import configuration from an export file'
+
+  static args = {
+    file: Args.string({ description: 'JSON export file name' })
+  }
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { args, flags } = await this.parse(ConnectImport)
+    const context = {
+      app: flags.app,
+      flags,
+      args,
+      auth: { password: this.heroku.auth }
+    }
+
+    const fName = args.file
+    await cli.action(`uploading ${fName}`, (async function () {
+      const connection = await api.withConnection(context, this.heroku)
       context.region = connection.region_url
       const url = '/api/v3/connections/' + connection.id + '/actions/import'
       const data = JSON.parse(fs.readFileSync(fName, 'utf8'))
-      yield api.request(context, 'POST', url, data)
-    }))
-  }))
+      await api.request(context, 'POST', url, data)
+    }.bind(this))())
+  }
 }

package/commands/connect/info.js

@@ -1,28 +1,32 @@
-'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'
+
+export default class ConnectInfo 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(ConnectInfo)
+    const context = {
+      app: flags.app,
+      flags,
+      args: {},
+      auth: { password: this.heroku.auth }
+    }
 
-module.exports = {
-  topic: 'connect',
-  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)
+    if (flags['check-for-new']) {
+      connections = await api.requestAppAccess(context, flags.app, flags, true, this.heroku)
     } else {
-      connections = yield api.withUserConnections(context, context.app, context.flags, true, heroku)
+      connections = await api.withUserConnections(context, flags.app, flags, true, this.heroku)
       if (connections.length === 0) {
-        connections = yield api.requestAppAccess(context, context.app, context.flags, true, heroku)
+        connections = await api.requestAppAccess(context, flags.app, flags, true, this.heroku)
       }
     }
 
@@ -31,7 +35,7 @@ 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.forEach(function (connection) {
         cli.styledHeader(`Connection [${connection.id}] / ${connection.resource_name} (${connection.state})`)
@@ -51,5 +55,5 @@ module.exports = {
         cli.log()
       })
     }
-  }))
+  }
 }

package/commands/connect/mapping/delete.js

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

package/commands/connect/mapping/diagnose.js

@@ -0,0 +1,35 @@
+import * as api from '../../../lib/connect/api.js'
+import cli from '@heroku/heroku-cli-util'
+import { displayResults } from '../diagnose.js'
+import { Command, flags } from '@heroku-cli/command'
+import { Args } from '@oclif/core'
+
+export default class MappingDiagnose extends Command {
+  static description = 'Display diagnostic information about a mapping'
+
+  static args = {
+    mapping: Args.string({ description: 'mapping name' })
+  }
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' }),
+    verbose: flags.boolean({ char: 'v', description: 'display passed and skipped check information as well' })
+  }
+
+  async run () {
+    const { args, flags } = await this.parse(MappingDiagnose)
+    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 mapping = await api.withMapping(connection, context.args.mapping)
+    const results = await cli.action('Diagnosing mapping', (async function () {
+      const url = '/api/v3/mappings/' + mapping.id + '/validations'
+      return await api.request(context, 'GET', url)
+    })())
+    cli.log() // Blank line to separate each section
+    cli.styledHeader(mapping.object_name)
+    displayResults(results.data, flags)
+  }
+}

package/commands/connect/mapping/reload.js

@@ -0,0 +1,33 @@
+import * as api from '../../../lib/connect/api.js'
+import cli from '@heroku/heroku-cli-util'
+import { Command, flags } from '@heroku-cli/command'
+import { Args } from '@oclif/core'
+
+export default class MappingReload extends Command {
+  static description = "Reload a mapping's data from Salesforce"
+
+  static args = {
+    mapping: Args.string({ description: 'mapping name' })
+  }
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { args, flags } = await this.parse(MappingReload)
+    const context = { app: flags.app, flags, args, auth: { password: this.heroku.auth } }
+
+    await cli.action(`initiating reload of ${args.mapping}`, (async function () {
+      const connection = await api.withConnection(context, this.heroku)
+      context.region = connection.region_url
+      const mapping = await api.withMapping(connection, context.args.mapping)
+
+      const response = await api.request(context, 'POST', '/api/v3/mappings/' + mapping.id + '/actions/reload')
+      if (response.status !== 202) {
+        throw new Error(response.data.message || 'unknown error')
+      }
+    }.bind(this))())
+  }
+}

package/commands/connect/mapping/state.js

@@ -0,0 +1,28 @@
+import * as api from '../../../lib/connect/api.js'
+import cli from '@heroku/heroku-cli-util'
+import { Command, flags } from '@heroku-cli/command'
+import { Args } from '@oclif/core'
+
+export default class MappingState extends Command {
+  static description = 'return a mapping state'
+
+  static args = {
+    mapping: Args.string({ description: 'mapping name' })
+  }
+
+  static flags = {
+    app: flags.app({ required: true }),
+    resource: flags.string({ description: 'specific connection resource name' })
+  }
+
+  async run () {
+    const { args, flags } = await this.parse(MappingState)
+    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 mapping = await api.withMapping(connection, context.args.mapping)
+
+    cli.log(mapping.state)
+  }
+}

package/commands/connect/mapping/write-errors.js

@@ -0,0 +1,28 @@
+import * as api from '../../../lib/connect/api.js'
+import { Command, flags } from '@heroku-cli/command'
+import { Args } from '@oclif/core'
+
+export default class MappingWriteErrors extends Command {
+  static description = 'Display the last 24 hours of write errors on this mapping'
+
+  static examples = [
+    '$ heroku connect:mapping:write-errors -a myapp --resource herokuconnect-twisted-123 Account'
+  ]
+
+  static args = {
+    name: Args.string({ description: 'Name of the mapping to retrieve errors for', required: true })
+  }
+
+  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 { args, flags } = await this.parse(MappingWriteErrors)
+    const context = { app: flags.app, flags, args, auth: { password: this.heroku.auth } }
+
+    await api.getWriteErrors(context, this.heroku)
+  }
+}

package/commands/connect/notifications/acknowledge.js

@@ -0,0 +1,34 @@
+import * as api from '../../../lib/connect/api.js'
+import { Command, flags } from '@heroku-cli/command'
+
+export default class NotificationsAcknowledge extends Command {
+  static description = 'Acknowledges notifications matching the given criteria'
+
+  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(NotificationsAcknowledge)
+    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, 'POST', '/api/v3/connections/' + connection.id + '/notifications/acknowledge', null, params)
+    if (response.status !== 204) {
+      throw new Error(response.data.message || 'unknown error')
+    }
+  }
+}