@heroku-cli/heroku-connect-plugin 0.11.0

package/commands/connect/mapping-reload.js

@@ -0,0 +1,31 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+const co = require('co')
+
+module.exports = {
+  topic: 'connect:mapping',
+  command: 'reload',
+  description: "Reload a mapping's data from Salesforce",
+  help: "Reload a mapping's data from Salesforce",
+  args: [
+    { name: 'mapping' }
+  ],
+  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(`initiating reload of ${context.args.mapping}`, co(function * () {
+      const connection = yield api.withConnection(context, heroku)
+      context.region = connection.region_url
+      const mapping = yield api.withMapping(connection, context.args.mapping)
+
+      const response = yield api.request(context, 'POST', '/api/v3/mappings/' + mapping.id + '/actions/reload')
+      if (response.status !== 202) {
+        throw new Error(response.data.message || 'unknown error')
+      }
+    }))
+  }))
+}

package/commands/connect/mapping-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:mapping',
+  command: 'state',
+  description: 'return a mapping state',
+  help: 'return a mapping state',
+  args: [
+    { name: 'mapping' }
+  ],
+  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)
+    context.region = connection.region_url
+    const mapping = yield api.withMapping(connection, context.args.mapping)
+
+    cli.log(mapping.state)
+  }))
+}

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

@@ -0,0 +1,34 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+
+module.exports = {
+  topic: 'connect:mapping',
+  command: 'write-errors',
+  description: 'Display the last 24 hours of write errors on this mapping',
+  examples: [
+    '$ heroku connect:mapping:write-errors -a myapp --resource herokuconnect-twisted-123 Account'
+  ],
+  args: [
+    {
+      name: 'name',
+      optional: false,
+      description: 'Name of the mapping to retrieve errors for'
+    }
+  ],
+  flags: [
+    {
+      name: 'resource',
+      description: 'specific connection resource name',
+      hasValue: true
+    },
+    {
+      name: 'json',
+      description: 'print errors as styled JSON',
+      hasValue: false
+    }
+  ],
+  needsApp: true,
+  needsAuth: true,
+  run: cli.command(api.getWriteErrors)
+}

package/commands/connect/pause.js

@@ -0,0 +1,24 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+const co = require('co')
+
+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)
+      context.region = connection.region_url
+      const url = '/api/v3/connections/' + connection.id + '/actions/pause'
+      yield api.request(context, 'POST', url)
+    }))
+  }))
+}

package/commands/connect/recover.js

@@ -0,0 +1,25 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+const co = require('co')
+
+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)
+      context.region = connection.region_url
+      const url = '/api/v3/connections/' + connection.id + '/actions/restart'
+      yield api.request(context, 'POST', url)
+    }))
+  }))
+}

package/commands/connect/resume.js

@@ -0,0 +1,24 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+const co = require('co')
+
+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)
+      context.region = connection.region_url
+      const url = '/api/v3/connections/' + connection.id + '/actions/resume'
+      yield api.request(context, 'POST', url)
+    }))
+  }))
+}

package/commands/connect/sf-auth.js

@@ -0,0 +1,75 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+const co = require('co')
+const http = require('http')
+
+const LOCAL_PORT = 18000
+
+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.connection.destroy()
+      this.close()
+
+      // Return control to the main command
+      resolve()
+    }).listen(LOCAL_PORT)
+  })
+}
+
+function * run (context, heroku) {
+  let redir
+  yield cli.action('fetching authorizing URL', co(function * () {
+    const connection = yield api.withConnection(context, 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 = yield api.request(context, 'POST', url, args)
+    redir = response.data.redirect
+
+    yield 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())
+}
+
+module.exports = {
+  topic: 'connect',
+  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))
+}

package/commands/connect/state.js

@@ -0,0 +1,34 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+const co = require('co')
+
+function * run (context, heroku) {
+  const connections = yield api.withUserConnections(context, context.app, context.flags, heroku)
+
+  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' }
+      ]
+    })
+  }
+}
+
+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))
+}

package/commands/connect/write-errors.js

@@ -0,0 +1,27 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+
+module.exports = {
+  topic: 'connect',
+  command: 'write-errors',
+  description: 'Display the last 24 hours of write errors on this connection',
+  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
+    }
+  ],
+  needsApp: true,
+  needsAuth: true,
+  run: cli.command(api.getWriteErrors)
+}

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

@@ -0,0 +1,68 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+const co = require('co')
+const inquirer = require('inquirer')
+
+const fetchKeys = co.wrap(function * (appName, context) {
+  const url = `/api/v3/apps/${appName}`
+  const response = yield api.request(context, 'GET', url)
+  const keys = []// new Array(response.json.db_keys.length);
+  response.data.db_keys.forEach(function (key) {
+    keys.push({
+      name: `${key.name} (${key.addon.plan})`,
+      value: key.name
+    })
+  })
+  return yield Promise.resolve(keys)
+})
+
+module.exports = {
+  topic: 'connect-events',
+  command: 'db:set',
+  description: 'Set database parameters',
+  help: "Set a connection's database config var and schema name",
+  flags: [
+    { name: 'resource', description: 'specific connection resource name', hasValue: true },
+    { name: 'db', description: 'Database config var name', hasValue: true },
+    { name: 'schema', description: 'Database schema name', hasValue: true }
+  ],
+  needsApp: true,
+  needsAuth: true,
+  run: cli.command(co.wrap(function * (context, heroku) {
+    const data = {
+      db_key: context.flags.db,
+      schema_name: context.flags.schema
+    }
+
+    const connection = yield api.withConnection(context, heroku, api.ADDON_TYPE_EVENTS)
+    context.region = connection.region_url
+
+    inquirer.prompt([
+      {
+        name: 'db_key',
+        type: 'list',
+        message: "Select the config var that points to the database you'd like to use",
+        choices: yield 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
+      }
+    ]).then(co.wrap(function * (answers) {
+      for (const key in answers) {
+        data[key] = answers[key]
+      }
+
+      yield cli.action('setting database parameters', co(function * () {
+        const url = `/api/v3/kafka-connections/${connection.id}`
+        yield api.request(context, 'PUT', url, data)
+      }))
+
+      cli.styledHash(data)
+    }))
+  }))
+}

package/commands/connect-events/info.js

@@ -0,0 +1,57 @@
+'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',
+  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)
+    } else {
+      connections = yield api.withUserConnections(context, context.app, context.flags, true, heroku, api.ADDON_TYPE_EVENTS)
+      if (connections.length === 0) {
+        connections = yield api.requestAppAcess(context, context.app, context.flags, true, heroku, api.ADDON_TYPE_EVENTS)
+      }
+    }
+
+    if (connections.length === 0) {
+      const instanceName = process.env.CONNECT_ADDON === 'connectqa' ? 'platformeventsqa' : 'herokuconnect'
+      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}`)
+    } else {
+      connections = yield api.withStreams(context, connections)
+      connections.forEach(function (connection) {
+        cli.styledHeader(`Connection [${connection.id}] / ${connection.resource_name} (${connection.state})`)
+        cli.log()
+        if (connection.streams.length > 0) {
+          cli.table(
+            connection.streams, {
+              columns: [
+                { key: 'object_name', label: 'Object Name' },
+                { key: 'state', label: 'State' }
+              ]
+            }
+          )
+        } else {
+          cli.log('No streams')
+        }
+        cli.log()
+      })
+    }
+  }))
+}

package/commands/connect-events/pause.js

@@ -0,0 +1,24 @@
+'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',
+  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)
+      context.region = connection.region_url
+      const url = `/api/v3/kafka-connections/${connection.id}/actions/pause`
+      yield api.request(context, 'POST', url)
+    }))
+  }))
+}

package/commands/connect-events/recover.js

@@ -0,0 +1,25 @@
+'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',
+  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)
+      context.region = connection.region_url
+      const url = `/api/v3/kafka-connections/${connection.id}/actions/recover`
+      yield api.request(context, 'POST', url)
+    }))
+  }))
+}

package/commands/connect-events/resume.js

@@ -0,0 +1,24 @@
+'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',
+  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)
+      context.region = connection.region_url
+      const url = `/api/v3/kafka-connections/${connection.id}/actions/resume`
+      yield api.request(context, 'POST', url)
+    }))
+  }))
+}

package/commands/connect-events/sf-auth.js

@@ -0,0 +1,75 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+const co = require('co')
+const http = require('http')
+
+const LOCAL_PORT = 18000
+
+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.connection.destroy()
+      this.close()
+
+      // Return control to the main command
+      resolve()
+    }).listen(LOCAL_PORT)
+  })
+}
+
+function * run (context, heroku) {
+  let redir
+  yield cli.action('fetching authorizing URL', co(function * () {
+    const connection = yield api.withConnection(context, heroku, api.ADDON_TYPE_EVENTS)
+    context.region = connection.region_url
+
+    const url = `/api/v3/kafka-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 = yield api.request(context, 'POST', url, args)
+    redir = response.data.redirect
+
+    yield 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())
+}
+
+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))
+}

package/commands/connect-events/state.js

@@ -0,0 +1,34 @@
+'use strict'
+const api = require('../../lib/connect/api.js')
+const cli = require('@heroku/heroku-cli-util')
+const co = require('co')
+
+function * run (context, heroku) {
+  const connections = yield api.withUserConnections(context, context.app, context.flags, heroku, true, api.ADDON_TYPE_EVENTS)
+
+  if (context.flags.json) {
+    cli.styledJSON(connections)
+  } else {
+    cli.table(connections, {
+      columns: [
+        { key: 'db_key', label: 'Kafka' },
+        { key: 'schema_name', label: 'Schema' },
+        { key: 'state', label: 'State' }
+      ]
+    })
+  }
+}
+
+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))
+}

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

@@ -0,0 +1,32 @@
+'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: 'create',
+  description: 'Create a stream',
+  help: 'Create a stream',
+  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) {
+    yield cli.action('creating stream', co(function * () {
+      const connection = yield api.withConnection(context, heroku, api.ADDON_TYPE_EVENTS)
+      context.region = connection.region_url
+      const response = yield api.request(
+        context, 'POST', `/api/v3/kafka-connections/${connection.id}/streams`,
+        { object_name: context.args.stream }
+      )
+      if (response.status !== 201) {
+        throw new Error(response.data.message || 'unknown error')
+      }
+    }))
+  }))
+}