heroku 11.0.0-alpha.11 → 11.0.0-alpha.12

package/lib/oldCommands/pipelines/update.js

@@ -1,39 +0,0 @@
-export {};
-/*
-import color from '@heroku-cli/color'
-import {Command, flags} from '@heroku-cli/command'
-import {StageCompletion} from '@heroku-cli/command/lib/completions'
-import {ux} from '@oclif/core'
-
-import {updateCoupling} from '../../lib/api'
-
-export default class PipelinesUpdate extends Command {
-  static description = 'update the app\'s stage in a pipeline'
-
-  static examples = [
-    '$ heroku pipelines:update -s staging -a my-app',
-  ]
-
-  static flags = {
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-    stage: flags.string({
-      char: 's',
-      description: 'new stage of app',
-      completion: StageCompletion,
-      required: true,
-    }),
-  }
-
-  async run() {
-    const {flags} = await this.parse(PipelinesUpdate)
-
-    const app = flags.app
-    const stage = flags.stage
-
-    ux.action.start(`Changing ${color.app(app)} to ${stage}`)
-    await updateCoupling(this.heroku, app, stage)
-    ux.action.stop()
-  }
-}
-*/

package/lib/oldCommands/ps/autoscale/disable.d.ts

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

package/lib/oldCommands/ps/autoscale/disable.js

@@ -1,43 +0,0 @@
-export {};
-/*
-import {Command, flags} from '@heroku-cli/command'
-import * as Heroku from '@heroku-cli/schema'
-import {ux} from '@oclif/core'
-
-const METRICS_HOST = 'api.metrics.heroku.com'
-
-export default class Disable extends Command {
-  static description = 'disable web dyno autoscaling'
-
-  static flags = {
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-  }
-
-  async run() {
-    const {flags} = await this.parse(Disable)
-    ux.action.start('Disabling dyno autoscaling')
-
-    const appResponse = await this.heroku.get<Heroku.App>(`/apps/${flags.app}`)
-    const app = appResponse.body
-    const monitorsResponse = await this.heroku.get<Heroku.Formation>(`/apps/${app.id}/formation/web/monitors`, {
-      hostname: METRICS_HOST,
-    })
-    const monitors = monitorsResponse.body
-    const scaleMonitor = monitors.find((m: any) => m.action_type === 'scale')
-
-    if (!scaleMonitor) throw new Error(`${flags.app} does not have autoscale enabled`)
-
-    await this.heroku.patch(`/apps/${app.id}/formation/web/monitors/${scaleMonitor.id}`, {
-      hostname: METRICS_HOST,
-      body: {
-        is_active: false,
-        period: 1,
-        op: 'GREATER_OR_EQUAL',
-      },
-    })
-
-    ux.action.stop()
-  }
-}
-*/

package/lib/oldCommands/ps/autoscale/enable.d.ts

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

package/lib/oldCommands/ps/autoscale/enable.js

@@ -1,103 +0,0 @@
-export {};
-/*
-import {Command, flags} from '@heroku-cli/command'
-import * as Heroku from '@heroku-cli/schema'
-import {ux} from '@oclif/core'
-import {App, Formation} from '../../../lib/types/fir'
-import {getGeneration} from '../../../lib/apps/generation'
-
-const METRICS_HOST = 'api.metrics.heroku.com'
-
-const isPerfOrPrivateTier = (size: string) => {
-  const applicableTiers = ['performance', 'private', 'shield']
-  return applicableTiers.some(tier => size.toLowerCase().includes(tier))
-}
-
-export default class Enable extends Command {
-  static description = 'enable web dyno autoscaling'
-
-  static flags = {
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-    min: flags.integer({required: true, description: 'minimum number of dynos'}),
-    max: flags.integer({required: true, description: 'maximum number of dynos'}),
-    p95: flags.integer({description: 'desired p95 response time'}),
-    notifications: flags.boolean({description: 'receive email notifications when the max dyno limit is reached'}),
-  }
-
-  async run() {
-    const {flags} = await this.parse(Enable)
-    ux.action.start('Enabling dyno autoscaling')
-
-    const [appResponse, formationResponse] = await Promise.all([
-      this.heroku.get<App>(`/apps/${flags.app}`, {
-        headers: {
-          Accept: 'application/vnd.heroku+json; version=3.sdk',
-        },
-      }),
-      this.heroku.get<Formation[]>(`/apps/${flags.app}/formation`, {
-        headers: {
-          Accept: 'application/vnd.heroku+json; version=3.sdk',
-        },
-      }),
-    ])
-    const app = appResponse.body
-    const formations = formationResponse.body
-    const webFormation = formations.find((f: any) => f.type === 'web')
-
-    if (getGeneration(app) === 'fir') {
-      throw new Error('Autoscaling is unavailable for apps in this space. See https://devcenter.heroku.com/articles/generations.')
-    }
-
-    if (!webFormation) throw new Error(`${flags.app} does not have any web dynos to scale`)
-
-    const {size} = webFormation
-
-    if (!isPerfOrPrivateTier(size || '')) {
-      throw new Error('Autoscaling is only available with Performance or Private dynos')
-    }
-
-    const {body} = await this.heroku.get<Heroku.Formation[]>(`/apps/${app.id}/formation/web/monitors`, {
-      hostname: METRICS_HOST,
-    })
-    const scaleMonitor = (body || []).find((m: any) => m.action_type === 'scale')
-
-    let updatedValues: any = {
-      is_active: true,
-      action_type: 'scale',
-      notification_period: 1440,
-      op: 'GREATER_OR_EQUAL',
-      period: 1,
-      notification_channels: flags.notifications ? ['app'] : [],
-    }
-
-    if (scaleMonitor) {
-      updatedValues = {...updatedValues,
-        min_quantity: flags.min || scaleMonitor.min_quantity,
-        max_quantity: flags.max || scaleMonitor.max_quantity,
-        value: flags.p95 ? flags.p95 : scaleMonitor.value,
-      }
-
-      await this.heroku.patch(`/apps/${app.id}/formation/web/monitors/${scaleMonitor.id}`,
-        {
-          body: updatedValues,
-          hostname: METRICS_HOST,
-        })
-    } else {
-      updatedValues = {...updatedValues,
-        name: 'LATENCY_SCALE',
-        min_quantity: flags.min,
-        max_quantity: flags.max,
-        value: flags.p95 ? flags.p95 : 1000,
-      }
-
-      await this.heroku.post(`/apps/${app.id}/formation/web/monitors`, {
-        hostname: METRICS_HOST,
-        body: updatedValues,
-      })
-    }
-
-    ux.action.stop()
-  }
-}
-*/

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

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

package/lib/oldCommands/ps/index.js

@@ -1,254 +0,0 @@
-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 {ago} from '../../lib/time'
-import {APIClient} from '@heroku-cli/command'
-import {AccountQuota} from '../../lib/types/account_quota'
-import {AppProcessTier} from '../../lib/types/app_process_tier'
-import {DynoExtended} from '../../lib/types/dyno_extended'
-import heredoc from 'tsheredoc'
-import {Account} from '../../lib/types/fir'
-
-function getProcessNumber(s: string) : number {
-  const [processType, dynoNumber] = (s.match(/^([^.]+)\.(.*)$/) || []).slice(1, 3)
-
-  if (!processType || !dynoNumber?.match(/^\d+$/))
-    return 0
-
-  return Number.parseInt(dynoNumber, 10)
-}
-
-function uniqueValues(value: string, index: number, self: string[]) : boolean {
-  return self.indexOf(value) === index
-}
-
-function byProcessNumber(a: DynoExtended, b: DynoExtended) : number {
-  return getProcessNumber(a.name) - getProcessNumber(b.name)
-}
-
-function byProcessName(a: DynoExtended, b: DynoExtended) : number {
-  if (a.name > b.name) {
-    return 1
-  }
-
-  if (b.name > a.name) {
-    return -1
-  }
-
-  return 0
-}
-
-function byProcessTypeAndNumber(a: DynoExtended, b: DynoExtended) : number {
-  if (a.type > b.type) {
-    return 1
-  }
-
-  if (b.type > a.type) {
-    return -1
-  }
-
-  return getProcessNumber(a.name) - getProcessNumber(b.name)
-}
-
-function truncate(s: string) {
-  return s.length > 35 ? `${s.slice(0, 34)}…` : s
-}
-
-function printExtended(dynos: DynoExtended[]) {
-  const sortedDynos = dynos.sort(byProcessTypeAndNumber)
-
-  hux.table<DynoExtended>(
-    sortedDynos,
-    {
-      ID: {get: (dyno: DynoExtended) => dyno.id},
-      Process: {get: (dyno: DynoExtended) => dyno.name},
-      State: {get: (dyno: DynoExtended) => `${dyno.state} ${ago(new Date(dyno.updated_at))}`},
-      Region: {get: (dyno: DynoExtended) => dyno.extended?.region ? dyno.extended.region : ''},
-      'Execution Plane': {get: (dyno: DynoExtended) => dyno.extended?.execution_plane ? dyno.extended.execution_plane : ''},
-      Fleet: {get: (dyno: DynoExtended) => dyno.extended?.fleet ? dyno.extended.fleet : ''},
-      Instance: {get: (dyno: DynoExtended) => dyno.extended?.instance ? dyno.extended.instance : ''},
-      IP: {get: (dyno: DynoExtended) => dyno.extended?.ip ? dyno.extended.ip : ''},
-      Port: {get: (dyno: DynoExtended) => dyno.extended?.port ? dyno.extended.port.toString() : ''},
-      AZ: {get: (dyno: DynoExtended) => dyno.extended?.az ? dyno.extended.az : ''},
-      Release: {get: (dyno: DynoExtended) => dyno.release.version},
-      Command: {get: (dyno: DynoExtended) => truncate(dyno.command)},
-      Route: {get: (dyno: DynoExtended) => dyno.extended?.route ? dyno.extended.route : ''},
-      Size: {get: (dyno: DynoExtended) => dyno.size},
-    },
-    {
-      'no-truncate': true,
-    },
-  )
-}
-
-async function printAccountQuota(heroku: APIClient, app: AppProcessTier, account: Account) {
-  if (app.process_tier !== 'free' && app.process_tier !== 'eco') {
-    return
-  }
-
-  if (app.owner.id !== account.id) {
-    return
-  }
-
-  const {body: quota} = await heroku.request<AccountQuota>(
-    `/accounts/${account.id}/actions/get-quota`,
-    {headers: {Accept: 'application/vnd.heroku+json; version=3.account-quotas'}},
-  ).catch(() => {
-    return {body: null}
-  })
-
-  if (!quota || (quota.id && quota.id === 'not_found')) {
-    return
-  }
-
-  const remaining = (quota.account_quota === 0) ? 0 : quota.account_quota - quota.quota_used
-  const percentage = (quota.account_quota === 0) ? 0 : Math.floor(remaining / quota.account_quota * 100)
-  const remainingMinutes = remaining / 60
-  const hours = Math.floor(remainingMinutes / 60)
-  const minutes = Math.floor(remainingMinutes % 60)
-  const appQuota = quota.apps.find(appQuota => {
-    return appQuota.app_uuid === app.id
-  })
-  const appQuotaUsed = appQuota ? appQuota.quota_used / 60 : 0
-  const appPercentage = appQuota ? Math.floor(appQuota.quota_used * 100 / quota.account_quota) : 0
-  const appHours = Math.floor(appQuotaUsed / 60)
-  const appMinutes = Math.floor(appQuotaUsed % 60)
-
-  if (app.process_tier === 'eco') {
-    ux.log(`Eco dyno hours quota remaining this month: ${hours}h ${minutes}m (${percentage}%)`)
-    ux.log(`Eco dyno usage for this app: ${appHours}h ${appMinutes}m (${appPercentage}%)`)
-    ux.log('For more information on Eco dyno hours, see:')
-    ux.log('https://devcenter.heroku.com/articles/eco-dyno-hours')
-    ux.log()
-  }
-
-  if (app.process_tier === 'free') {
-    ux.log(`Free dyno hours quota remaining this month: ${hours}h ${minutes}m (${percentage}%)`)
-    ux.log(`Free dyno usage for this app: ${appHours}h ${appMinutes}m (${appPercentage}%)`)
-    ux.log('For more information on dyno sleeping and how to upgrade, see:')
-    ux.log('https://devcenter.heroku.com/articles/dyno-sleeping')
-    ux.log()
-  }
-}
-
-function decorateOneOffDyno(dyno: DynoExtended) : string {
-  const since = ago(new Date(dyno.updated_at))
-  // eslint-disable-next-line unicorn/explicit-length-check
-  const size = dyno.size || '1X'
-  const state = dyno.state === 'up' ? color.green(dyno.state) : color.yellow(dyno.state)
-
-  return `${dyno.name} (${color.cyan(size)}): ${state} ${color.dim(since)}: ${dyno.command}`
-}
-
-function decorateCommandDyno(dyno: DynoExtended) : string {
-  const since = ago(new Date(dyno.updated_at))
-  const state = dyno.state === 'up' ? color.green(dyno.state) : color.yellow(dyno.state)
-
-  return `${dyno.name}: ${state} ${color.dim(since)}`
-}
-
-function printDynos(dynos: DynoExtended[]) : void {
-  const oneOffs = dynos.filter(d => d.type === 'run').sort(byProcessNumber)
-  const commands = dynos.filter(d => d.type !== 'run').map(d => d.command).filter(uniqueValues)
-
-  // Print one-off dynos
-  if (oneOffs.length > 0) {
-    hux.styledHeader(`${color.green('run')}: one-off processes (${color.yellow(oneOffs.length.toString())})`)
-    oneOffs.forEach(dyno => ux.log(decorateOneOffDyno(dyno)))
-    ux.log()
-  }
-
-  // Print dynos grouped by command
-  commands.forEach(function (command) {
-    const commandDynos = dynos.filter(d => d.command === command).sort(byProcessNumber)
-    const type = commandDynos[0].type
-    // eslint-disable-next-line unicorn/explicit-length-check
-    const size = commandDynos[0].size || '1X'
-
-    hux.styledHeader(`${color.green(type)} (${color.cyan(size)}): ${command} (${color.yellow(commandDynos.length.toString())})`)
-    for (const dyno of commandDynos)
-      ux.log(decorateCommandDyno(dyno))
-    ux.log()
-  })
-}
-
-export default class Index extends Command {
-  static topic = 'ps'
-  static description = 'list dynos for an app'
-  static strict = false
-  static usage = 'ps [TYPE [TYPE ...]]'
-
-  static examples = [heredoc`
-    $ heroku ps
-    === run: one-off dyno
-    run.1: up for 5m: bash
-    === web: bundle exec thin start -p $PORT
-    web.1: created for 30s
-  `, heredoc`
-    $ heroku ps run # specifying types
-    === run: one-off dyno
-    run.1: up for 5m: bash
-  `]
-
-  static flags = {
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-    json: flags.boolean({description: 'display as json'}),
-    extended: flags.boolean({char: 'x', hidden: true}), // only works with sudo privileges
-  }
-
-  public async run(): Promise<void> {
-    const {flags, ...restParse} = await this.parse(Index)
-    const {app, json, extended} = flags
-    const types = restParse.argv as string[]
-    const suffix = extended ? '?extended=true' : ''
-    const promises = {
-      dynos: this.heroku.request<DynoExtended[]>(`/apps/${app}/dynos${suffix}`, {
-        headers: {Accept: 'application/vnd.heroku+json; version=3.sdk'},
-      }),
-      appInfo: this.heroku.request<AppProcessTier>(`/apps/${app}`, {
-        headers: {Accept: 'application/vnd.heroku+json; version=3.sdk'},
-      }),
-      accountInfo: this.heroku.request<Account>('/account', {
-        headers: {Accept: 'application/vnd.heroku+json; version=3.sdk'},
-      }),
-    }
-    const [{body: dynos}, {body: appInfo}, {body: accountInfo}] = await Promise.all([promises.dynos, promises.appInfo, promises.accountInfo])
-    const shielded = appInfo.space && appInfo.space.shield
-
-    if (shielded) {
-      dynos.forEach(d => {
-        d.size = d.size.replace('Private-', 'Shield-')
-      })
-    }
-
-    let selectedDynos = dynos
-
-    if (types.length > 0) {
-      selectedDynos = selectedDynos.filter(dyno => types.find((t: string) => dyno.type === t))
-      types.forEach(t => {
-        if (!selectedDynos.some(d => d.type === t)) {
-          throw new Error(`No ${color.cyan(t)} dynos on ${color.magenta(app)}`)
-        }
-      })
-    }
-
-    selectedDynos = selectedDynos.sort(byProcessName)
-
-    if (json)
-      hux.styledJSON(selectedDynos)
-    else if (extended)
-      printExtended(selectedDynos)
-    else {
-      await printAccountQuota(this.heroku, appInfo, accountInfo)
-      if (selectedDynos.length === 0)
-        ux.log(`No dynos on ${color.magenta(app)}`)
-      else
-        printDynos(selectedDynos)
-    }
-  }
-}
-*/

package/lib/oldCommands/ps/restart.d.ts

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

package/lib/oldCommands/ps/restart.js

@@ -1,78 +0,0 @@
-export {};
-/*
-import {Command, flags} from '@heroku-cli/command'
-import * as Heroku from '@heroku-cli/schema'
-import color from '@heroku-cli/color'
-import {Args, ux} from '@oclif/core'
-import {ProcessTypeCompletion} from '@heroku-cli/command/lib/completions'
-import heredoc from 'tsheredoc'
-export default class Restart extends Command {
-  static description = heredoc(`
-    restart an app dyno or process type
-    if neither --dyno nor --type are specified, restarts all dynos on app
-  `)
-
-  static topic = 'ps'
-  static aliases = ['dyno:restart']
-  static hiddenAliases = ['restart']
-
-  static examples = [
-    '$ heroku ps:restart --app myapp --dyno-name web.1',
-    '$ heroku ps:restart --app myapp --process-type web',
-    '$ heroku ps:restart --app myapp',
-  ]
-
-  static args = {
-    dyno: Args.string({description: 'name of the dyno to restart', required: false, deprecated: true}),
-  }
-
-  static flags = {
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-    'dyno-name': flags.string({
-      char: 'd',
-      description: 'name of the dyno to restart',
-    }),
-    'process-type': flags.string({
-      char: 'p',
-      description: 'name of the process type to restart',
-      completion: ProcessTypeCompletion,
-      exclusive: ['dyno-name'],
-    }),
-  }
-
-  async run() {
-    const {args, flags} = await this.parse(Restart)
-    const app = flags.app
-    const dyno = flags['dyno-name'] || args.dyno
-    const type = flags['process-type']
-    let msg = 'Restarting'
-    let restartUrl
-
-    if (type) {
-      msg += ` all ${color.cyan(type)} dynos`
-      restartUrl = `/apps/${app}/formations/${encodeURIComponent(type)}`
-    } else if (dyno) {
-      if (args.dyno) {
-        ux.warn(`DYNO is a deprecated argument. Use ${color.cmd('--dyno-name')} or ${color.cmd('--process-type')} instead.`)
-      }
-
-      msg += ` dyno ${color.cyan(dyno)}`
-      restartUrl = `/apps/${app}/dynos/${encodeURIComponent(dyno)}`
-    } else {
-      msg += ' all dynos'
-      restartUrl = `/apps/${app}/dynos`
-    }
-
-    msg += ` on ${color.app(app)}`
-
-    ux.action.start(msg)
-    await this.heroku.delete<Heroku.Dyno>(restartUrl, {
-      headers: {
-        Accept: 'application/vnd.heroku+json; version=3.sdk',
-      },
-    })
-    ux.action.stop()
-  }
-}
-*/

package/lib/oldCommands/ps/scale.d.ts

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

package/lib/oldCommands/ps/scale.js

@@ -1,95 +0,0 @@
-export {};
-/*
-import color from '@heroku-cli/color'
-import {Command, flags} from '@heroku-cli/command'
-import {ux} from '@oclif/core'
-import * as Heroku from '@heroku-cli/schema'
-import {compact} from 'lodash'
-import heredoc from 'tsheredoc'
-
-const emptyFormationErr = (app: string) => {
-  return new Error(`No process types on ${color.magenta(app)}.\nUpload a Procfile to add process types.\nhttps://devcenter.heroku.com/articles/procfile`)
-}
-
-export default class Scale extends Command {
-  static strict = false
-  static description = heredoc`
-    scale dyno quantity up or down
-    Appending a size (eg. web=2:Standard-2X) allows simultaneous scaling and resizing.
-
-    Omitting any arguments will display the app's current dyno formation, in a
-    format suitable for passing back into ps:scale.
-  `
-  static examples = [heredoc`
-    $ heroku ps:scale web=3:Standard-2X worker+1 --app APP
-    Scaling dynos... done, now running web at 3:Standard-2X, worker at 1:Standard-1X.
-  `, heredoc`
-    $ heroku ps:scale --app APP
-    web=3:Standard-2X worker=1:Standard-1X
-  `]
-
-  static aliases = ['dyno:scale']
-  static hiddenAliases = ['scale']
-  static flags = {
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-  }
-
-  public async run(): Promise<void> {
-    const {flags, ...restParse} = await this.parse(Scale)
-    const argv = restParse.argv as string[]
-    const {app} = flags
-
-    function parse(args: string[]) {
-      return compact(args.map(arg => {
-        const change = arg.match(/^([\w-]+)([=+-]\d+)(?::([\w-]+))?$/)
-        if (!change)
-          return
-        const quantity = change[2][0] === '=' ? change[2].slice(1) : change[2]
-        if (change[3])
-          change[3] = change[3].replace('Shield-', 'Private-')
-        return {type: change[1], quantity, size: change[3]}
-      }))
-    }
-
-    const changes = parse(argv)
-
-    if (changes.length === 0) {
-      const {body: formation} = await this.heroku.get<Heroku.Formation[]>(`/apps/${app}/formation`)
-      const {body: appProps} = await this.heroku.get<Heroku.App>(`/apps/${app}`)
-      const shielded = appProps.space && appProps.space.shield
-      if (shielded) {
-        formation.forEach(d => {
-          if (d.size !== undefined) {
-            d.size = d.size.replace('Private-', 'Shield-')
-          }
-        })
-      }
-
-      if (formation.length === 0) {
-        throw emptyFormationErr(app)
-      }
-
-      ux.log(formation.map(d => `${d.type}=${d.quantity}:${d.size}`)
-        .sort()
-        .join(' '))
-    } else {
-      ux.action.start('Scaling dynos')
-      const {body: appProps} = await this.heroku.get<Heroku.App>(`/apps/${app}`)
-      const {body: formation} = await this.heroku.patch<Heroku.Formation[]>(`/apps/${app}/formation`, {body: {updates: changes}})
-      const shielded = appProps.space && appProps.space.shield
-      if (shielded) {
-        formation.forEach(d => {
-          if (d.size !== undefined) {
-            d.size = d.size.replace('Private-', 'Shield-')
-          }
-        })
-      }
-
-      const output = formation.filter(f => changes.find(c => c.type === f.type))
-        .map(d => `${color.green(d.type || '')} at ${d.quantity}:${d.size}`)
-      ux.action.stop(`done, now running ${output.join(', ')}`)
-    }
-  }
-}
-*/

package/lib/oldCommands/ps/stop.d.ts

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