heroku 10.13.2-beta.0 → 11.0.0-alpha.1

package/lib/oldCommands/redis/maintenance.js

@@ -0,0 +1,75 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import redisApi, {RedisApiResponse, RedisMaintenanceWindowResponse} from '../../lib/redis/api'
+import heredoc from 'tsheredoc'
+import {App} from '@heroku-cli/schema'
+
+export default class Maintenance extends Command {
+  static topic = 'redis'
+  static description = heredoc`
+    manage maintenance windows
+    Set or change the maintenance window for your Redis instance
+  `
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    window: flags.string({
+      char: 'w',
+      description: 'set weekly UTC maintenance window (format: "Day HH:MM", where MM is 00 or 30)',
+      hasValue: true,
+      required: false,
+    }),
+    run: flags.boolean({description: 'start maintenance', required: false}),
+    force: flags.boolean({
+      char: 'f',
+      description: 'start maintenance without entering application maintenance mode',
+      required: false,
+    }),
+  }
+
+  static args = {
+    database: Args.string({required: false, description: 'name of the Key-Value Store database. If omitted, it defaults to the primary database associated with the app.'}),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(Maintenance)
+    const {app: appName, window, run, force} = flags
+    const {database} = args
+    const api = redisApi(appName, database, false, this.heroku)
+
+    const addon = await api.getRedisAddon()
+
+    if (addon.plan.name?.match(/hobby/)) {
+      ux.error('redis:maintenance is not available for hobby-dev instances', {exit: 1})
+    }
+
+    if (window) {
+      if (!window.match(/[A-Za-z]{3,10} \d\d?:[03]0/)) {
+        ux.error('Maintenance windows must be "Day HH:MM", where MM is 00 or 30.', {exit: 1})
+      }
+
+      const {body: maintenance} = await api.request<RedisMaintenanceWindowResponse>(
+        `/redis/v0/databases/${addon.name}/maintenance_window`, 'PUT', {description: window},
+      )
+      ux.log(`Maintenance window for ${addon.name} (${addon.config_vars.join(', ')}) set to ${maintenance.window}.`)
+      return
+    }
+
+    if (run) {
+      const {body: app} = await this.heroku.get<App>(`/apps/${appName}`)
+      if (!app.maintenance && !force) {
+        ux.error('Application must be in maintenance mode or --force flag must be used', {exit: 1})
+      }
+
+      const {body: maintenance} = await api.request<RedisApiResponse>(`/redis/v0/databases/${addon.name}/maintenance`, 'POST')
+      ux.log(maintenance.message)
+      return
+    }
+
+    const {body: maintenance} = await api.request<RedisApiResponse>(`/redis/v0/databases/${addon.name}/maintenance`, 'GET')
+    ux.log(maintenance.message)
+  }
+}
+*/

package/lib/oldCommands/redis/maxmemory.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/redis/maxmemory.js

@@ -0,0 +1,46 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import redisApi from '../../lib/redis/api'
+import {RedisFormationConfigResponse} from '../../lib/redis/api'
+
+export default class MaxMemory extends Command {
+  static topic = 'redis'
+  static description = `set the key eviction policy when instances reach their storage limit
+  Available policies for key eviction include:
+
+  noeviction      # returns errors when memory limit is reached
+  allkeys-lfu     # removes less frequently used keys first
+  volatile-lfu    # removes less frequently used keys first that have an expiry set
+  allkeys-lru     # removes less recently used keys first
+  volatile-lru    # removes less recently used keys first that have an expiry set
+  allkeys-random  # evicts random keys
+  volatile-random # evicts random keys but only those that have an expiry set
+  volatile-ttl    # only evicts keys with an expiry set and a short TTL
+`
+  static flags = {
+    app: flags.app({required: true}),
+    policy: flags.string({char: 'p', description: 'set policy name', required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    database: Args.string({description: 'name of the Key-Value Store database. If omitted, it defaults to the primary database associated with the app.'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(MaxMemory)
+    const {app, policy} = flags
+    const {database} = args
+
+    const addon = await redisApi(app, database, false, this.heroku).getRedisAddon()
+
+    const {body: config} = await redisApi(app, database, false, this.heroku)
+      .request<RedisFormationConfigResponse>(`/redis/v0/databases/${addon.name}/config`, 'PATCH', {maxmemory_policy: policy})
+    const configVars = addon.config_vars || []
+    ux.log(`Maxmemory policy for ${addon.name} (${configVars.join(', ')}) set to ${config.maxmemory_policy.value}.`)
+    ux.log(`${config.maxmemory_policy.value} ${config.maxmemory_policy.values[config.maxmemory_policy.value]}.`)
+  }
+}
+*/

package/lib/oldCommands/redis/promote.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/redis/promote.js

@@ -0,0 +1,43 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+import apiFactory from '../../lib/redis/api'
+export default class Promote extends Command {
+  static topic = 'redis'
+  static description = 'sets DATABASE as your REDIS_URL'
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    database: Args.string({required: false, description: 'name of the Key-Value Store database. If omitted, it defaults to the primary database associated with the app.'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Promote)
+    const api = apiFactory(flags.app, args.database, false, this.heroku)
+    const {body: addonsList} = await this.heroku.get<Required<Heroku.AddOn>[]>(`/apps/${flags.app}/addons`)
+    const addon = await api.getRedisAddon(addonsList)
+    const redisFilter = api.makeAddonsFilter('REDIS_URL')
+    const redis = redisFilter(addonsList) as Required<Heroku.AddOn>[]
+    if (redis.length === 1 && redis[0].config_vars.filter((c: string) => c.endsWith('_URL')).length === 1) {
+      const attachment = redis[0]
+      await this.heroku.post('/addon-attachments', {
+        body: {
+          app: {name: flags.app}, addon: {name: attachment.name}, confirm: flags.app,
+        },
+      })
+    }
+
+    ux.log(`Promoting ${addon.name} to REDIS_URL on ${flags.app}`)
+    await this.heroku.post('/addon-attachments', {
+      body: {
+        app: {name: flags.app}, addon: {name: addon.name}, confirm: flags.app, name: 'REDIS',
+      },
+    })
+  }
+}
+*/

package/lib/oldCommands/redis/stats-reset.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/redis/stats-reset.js

@@ -0,0 +1,40 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import redisApi, {RedisApiResponse} from '../../lib/redis/api'
+import confirmCommand from '../../lib/confirmCommand'
+import heredoc from 'tsheredoc'
+import color from '@heroku-cli/color'
+
+export default class StatsReset extends Command {
+  static topic = 'redis'
+  static description = 'reset all stats covered by RESETSTAT (https://redis.io/commands/config-resetstat)'
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    confirm: flags.string({char: 'c'}),
+  }
+
+  static args = {
+    database: Args.string({description: 'name of the Key-Value Store database. If omitted, it defaults to the primary database associated with the app.'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(StatsReset)
+    const {app, confirm} = flags
+    const {database} = args
+    const addon = await redisApi(app, database, false, this.heroku).getRedisAddon()
+    const warning = heredoc(`
+      WARNING: Irreversible action.
+      All stats covered by RESETSTAT will be reset on ${color.addon(addon.name || '')}.
+    `)
+    await confirmCommand(app, confirm, warning)
+
+    ux.action.start(`Resetting stats on ${color.addon(addon.name || '')}`)
+    const {body: response} = await redisApi(app, database, false, this.heroku)
+      .request<RedisApiResponse>(`/redis/v0/databases/${addon.id}/stats/reset`, 'POST', {})
+    ux.action.stop(response.message)
+  }
+}
+*/

package/lib/oldCommands/redis/timeout.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/redis/timeout.js

@@ -0,0 +1,44 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import redisApi from '../../lib/redis/api'
+
+type RedisConfigResponse = {
+  timeout: {
+    value: number
+  }
+}
+
+export default class Timeout extends Command {
+  static topic = 'redis'
+  static description = `set the number of seconds to wait before killing idle connections
+    A value of zero means that connections will not be closed.
+  `
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    seconds: flags.integer({char: 's', description: 'set timeout value', required: true}),
+  }
+
+  static args = {
+    database: Args.string({description: 'name of the Key-Value Store database. If omitted, it defaults to the primary database associated with the app.'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Timeout)
+    const {app, seconds} = flags
+    const {database} = args
+    const addon = await redisApi(app, database, false, this.heroku).getRedisAddon()
+    const {body: response} = await redisApi(app, database, false, this.heroku)
+      .request<RedisConfigResponse>(`/redis/v0/databases/${addon.id}/config`, 'PATCH', {timeout: seconds})
+    ux.log(`Timeout for ${addon.name} (${addon.config_vars.join(', ')}) set to ${response.timeout.value} seconds.`)
+    if (response.timeout.value === 0) {
+      ux.log('Connections to the Redis instance can idle indefinitely.')
+    } else {
+      ux.log(`Connections to the Redis instance will be stopped after idling for ${response.timeout.value} seconds.`)
+    }
+  }
+}
+*/

package/lib/oldCommands/redis/upgrade.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/redis/upgrade.js

@@ -0,0 +1,41 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import redisApi, {RedisApiResponse} from '../../lib/redis/api'
+import confirmCommand from '../../lib/confirmCommand'
+import heredoc from 'tsheredoc'
+import color from '@heroku-cli/color'
+
+export default class Upgrade extends Command {
+  static topic = 'redis'
+  static description = 'perform in-place version upgrade'
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    version: flags.string({char: 'v', required: true}),
+    confirm: flags.string({char: 'c'}),
+  }
+
+  static args = {
+    database: Args.string({description: 'name of the Key-Value Store database. If omitted, it defaults to the primary database associated with the app.'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Upgrade)
+    const {app, version, confirm} = flags
+    const {database} = args
+    const addon = await redisApi(app, database, false, this.heroku).getRedisAddon()
+    const warning = heredoc(`
+      WARNING: Irreversible action.
+      Redis database will be upgraded to ${color.configVar(version)}. This cannot be undone.
+    `)
+    await confirmCommand(app, confirm, warning)
+
+    ux.action.start(`Requesting upgrade of ${color.addon(addon.name || '')} to ${version}`)
+    const {body: response} = await redisApi(app, database, false, this.heroku)
+      .request<RedisApiResponse>(`/redis/v0/databases/${addon.id}/upgrade`, 'POST', {version: version})
+    ux.action.stop(response.message)
+  }
+}
+*/

package/lib/oldCommands/redis/wait.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/redis/wait.js

@@ -0,0 +1,71 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import redisApi, {RedisFormationWaitResponse} from '../../lib/redis/api'
+import {HTTPError} from '@heroku/http-call'
+
+const wait = (ms: number) => new Promise(resolve => {
+  setTimeout(resolve, ms)
+})
+
+export default class Wait extends Command {
+  static topic = 'redis';
+  static description = 'wait for Redis instance to be available';
+  static flags = {
+    'wait-interval': flags.string({description: 'how frequently to poll in seconds'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  };
+
+  static args = {
+    database: Args.string({required: false, description: 'name of the Key-Value Store database. If omitted, it defaults to the primary database associated with the app.'}),
+  };
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Wait)
+    const {app, 'wait-interval': waitInterval} = flags
+    const {database} = args
+    const api = redisApi(app, database, false, this.heroku)
+    const addon = await api.getRedisAddon()
+
+    const waitFor = async () => {
+      let interval = waitInterval && Number.parseInt(waitInterval, 10)
+      if (!interval || interval < 0)
+        interval = 5
+      let status: RedisFormationWaitResponse
+      let waiting = false
+      while (true) {
+        try {
+          status = await api.request<RedisFormationWaitResponse>(`/redis/v0/databases/${addon.name}/wait`).then(response => response.body)
+        } catch (error) {
+          const httpError = error as HTTPError
+          if (httpError.statusCode !== 404)
+            throw httpError
+          status = {message: 'not found', 'waiting?': true}
+        }
+
+        if (!status['waiting?']) {
+          if (waiting) {
+            ux.action.stop(status.message)
+          }
+
+          return
+        }
+
+        if (!waiting) {
+          waiting = true
+          ux.action.start(`Waiting for database ${color.yellow(addon.name)}`, status.message)
+        }
+
+        ux.action.status = status.message
+
+        await wait(interval * 1000)
+      }
+    }
+
+    await waitFor()
+  }
+}
+*/

package/lib/oldCommands/releases/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/releases/index.js

@@ -0,0 +1,156 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import {truncate} from 'lodash'
+import * as Heroku from '@heroku-cli/schema'
+import * as statusHelper from '../../lib/releases/status_helper'
+import * as time from '../../lib/time'
+import stripAnsi from 'strip-ansi'
+import {table} from '@oclif/core/lib/cli-ux/styled/table'
+import Columns = table.Columns
+
+const getDescriptionTruncation = function (releases: Heroku.Formation[], columns: Columns<Heroku.Release>, optimizeKey: string) {
+  // width management here is quite opaque.
+  // This entire function is to determine how much of Formation.description should be truncated to accommodate for Formation.status. They both go in the same column.
+  // Nothing else is truncated and the table is passed `'no-truncate': true` in options.
+  let optimizationWidth = 0
+  const optimizationWidthMap: Record<string, number> = {}
+  for (const key of Object.keys(columns)) {
+    optimizationWidthMap[key] = 0
+  }
+
+  for (const row of releases) {
+    for (const colKey in row) {
+      if (colKey === optimizeKey) {
+        continue
+      }
+
+      for (const [key, col] of Object.entries(columns)) {
+        const parts = key.split('.')
+        const matchKey = parts[0]
+        if (matchKey !== colKey) {
+          continue
+        }
+
+        let colValue = row
+        for (const part of parts) {
+          colValue = colValue[part]
+        }
+
+        let formattedValue
+        if (col.get) {
+          formattedValue = col.get(row)
+        } else {
+          formattedValue = colValue.toString()
+        }
+
+        if (key !== optimizeKey) {
+          optimizationWidthMap[key] = Math.max(
+            optimizationWidthMap[key],
+            stripAnsi(formattedValue).length,
+          )
+        }
+      }
+    }
+  }
+
+  for (const key of Object.keys(columns)) {
+    if (key !== optimizeKey) {
+      optimizationWidth += optimizationWidthMap[key] + 2
+    }
+  }
+
+  return optimizationWidth
+}
+
+export default class Index extends Command {
+  static topic = 'releases'
+  static description = 'display the releases for an app'
+  static examples = [
+    'v1 Config add FOO_BAR email@example.com 2015/11/17 17:37:41 (~ 1h ago)',
+    'v2 Config add BAR_BAZ email@example.com 2015/11/17 17:37:41 (~ 1h ago)',
+    'v3 Config add BAZ_QUX email@example.com 2015/11/17 17:37:41 (~ 1h ago)',
+  ]
+
+  static flags = {
+    num: flags.string({char: 'n', description: 'number of releases to show'}),
+    json: flags.boolean({description: 'output releases in json format'}),
+    extended: flags.boolean({char: 'x', hidden: true}),
+    remote: flags.remote(),
+    app: flags.app({required: true}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags} = await this.parse(Index)
+    const {app, num, json, extended} = flags
+
+    const url = `/apps/${app}/releases${extended ? '?extended=true' : ''}`
+
+    const {body: releases} = await this.heroku.request<Heroku.Release[]>(url, {
+      partial: true,
+      headers: {
+        Range: `version ..; max=${num || 15}, order=desc`,
+        Accept: 'application/vnd.heroku+json; version=3.sdk',
+      },
+    })
+
+    let optimizationWidth = 0
+
+    const descriptionWithStatus = function (release: Heroku.Release) {
+      const {description} = release
+      const width = () => process.stdout?.columns && process.stdout.columns > 80 ? process.stdout.columns : 80
+      const trunc = (l: number, s?: string) => {
+        if (process.stdout.isTTY) {
+          return truncate(s, {length: width() - (optimizationWidth + l), omission: '…'})
+        }
+
+        return s
+      }
+
+      const status = statusHelper.description(release)
+      if (status) {
+        const sc = color[statusHelper.color(release.status)](status)
+        return trunc(status.length + 1, description) + ' ' + sc
+      }
+
+      return trunc(0, description)
+    }
+
+    const columns: Columns<Heroku.Formation> = {
+      // column name "v" as ux.table will make it's width at least "version" even though 'no-header': true
+      v: {get: release => color[statusHelper.color(release.status)]('v' + release.version)},
+      description: {get: descriptionWithStatus},
+      user: {get: ({user}) => color.magenta(user?.email || '')},
+      created_at: {get: ({created_at}) => time.ago(new Date(created_at || ''))},
+      slug_id: {extended: true, get: ({extended}) => extended?.slug_id},
+      slug_uuid: {extended: true, get: ({extended}) => extended?.slug_uuid},
+    }
+
+    // `getDescriptionTruncation` is dependent on `columns` being defined and thus `descriptionWithStatus`.
+    // `descriptionWithStatus` requires `optimizationWidth` to be defined. Redefine here before `descriptionWithStatus` is actually called.
+    optimizationWidth = getDescriptionTruncation(releases, columns, 'description')
+
+    if (json) {
+      ux.log(JSON.stringify(releases, null, 2))
+    } else if (releases.length === 0) {
+      ux.log(`${app} has no releases.`)
+    } else {
+      let header = `${app} Releases`
+      const currentRelease = releases.find(r => r.current === true)
+      if (currentRelease) {
+        header += ' - ' + color.cyan(`Current: v${currentRelease.version}`)
+      }
+
+      hux.styledHeader(header)
+      hux.table(
+        releases,
+        columns,
+        {'no-header': true, 'no-truncate': true,  extended},
+      )
+    }
+  }
+}
+*/

package/lib/oldCommands/releases/info.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/releases/info.js

@@ -0,0 +1,68 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import * as Heroku from '@heroku-cli/schema'
+// import * as shellescape from 'shell-escape'
+import {parse, quote} from '../../lib/config/quote'
+
+const {forEach} = require('lodash')
+
+import {findByLatestOrId} from '../../lib/releases/releases'
+import {description, color as getStatusColor} from '../../lib/releases/status_helper'
+
+export default class Info extends Command {
+    static topic = 'releases';
+    static description = 'view detailed information for a release';
+    static flags = {
+      json: flags.boolean({description: 'output in json format'}),
+      shell: flags.boolean({char: 's', description: 'output in shell format'}),
+      remote: flags.remote(),
+      app: flags.app({required: true}),
+    };
+
+    static args = {
+      release: Args.string({description: 'ID of the release. If omitted, we use the last release ID.'}),
+    };
+
+    public async run(): Promise<void> {
+      const {flags, args} = await this.parse(Info)
+      const {json, shell, app} = flags
+      const release = await findByLatestOrId(this.heroku, app, args.release)
+
+      if (json) {
+        hux.styledJSON(release)
+      } else {
+        let releaseChange = release.description
+        const status = description(release)
+        const statusColor = getStatusColor(release.status)
+        const userEmail = release?.user?.email ?? ''
+        const {body: config} = await this.heroku.get<Heroku.ConfigVars>(`/apps/${app}/releases/${release.version}/config-vars`)
+
+        if (status) {
+          releaseChange += ' (' + color[statusColor](status) + ')'
+        }
+
+        hux.styledHeader(`Release ${color.cyan('v' + release.version)}`)
+        hux.styledObject({
+          'Add-ons': release.addon_plan_names,
+          Change: releaseChange,
+          By: userEmail,
+          'Eligible for Rollback?': release.eligible_for_rollback ? 'Yes' : 'No',
+          When: release.created_at,
+        })
+        ux.log()
+        hux.styledHeader(`${color.cyan('v' + release.version)} Config vars`)
+        if (shell) {
+          forEach(config, (v: string, k: string) => {
+            ux.log(`${k}=${shellescape([v])}`)
+          })
+        } else {
+          hux.styledObject(config)
+        }
+      }
+    }
+}
+*/

package/lib/oldCommands/releases/output.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/releases/output.js

@@ -0,0 +1,42 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {findByLatestOrId} from '../../lib/releases/releases'
+import {stream} from '../../lib/releases/output'
+
+export default class Output extends Command {
+    static topic = 'releases';
+    static description = 'View the release command output';
+    static flags = {
+      remote: flags.remote(),
+      app: flags.app({required: true}),
+    };
+
+    static args = {
+      release: Args.string({description: 'ID of the release. If omitted, we use the last release ID.'}),
+    };
+
+    public async run(): Promise<void> {
+      const {flags, args} = await this.parse(Output)
+      const {app} = flags
+      const release = await findByLatestOrId(this.heroku, app, args.release)
+      const streamUrl = release.output_stream_url
+
+      if (!streamUrl) {
+        ux.warn(`Release v${release.version} has no release output available.`)
+        return
+      }
+
+      await stream(streamUrl)
+        .catch(error => {
+          if (error.statusCode === 404 || error.response?.statusCode === 404) {
+            ux.warn('Release command not started yet. Please try again in a few seconds.')
+            return
+          }
+
+          throw error
+        })
+    }
+}
+*/

package/lib/oldCommands/releases/retry.d.ts

@@ -0,0 +1 @@
+export {};