heroku 11.0.0-alpha.11 → 11.0.0-alpha.13

package/lib/oldCommands/ps/stop.js

@@ -1,73 +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 Stop extends Command {
-  static description = 'stop an app dyno or process type'
-  static topic = 'ps'
-  static aliases = ['dyno:stop', 'ps:kill', 'dyno:kill']
-  static hiddenAliases = ['stop', 'kill']
-
-  static examples = [
-    '$ heroku ps:stop --app myapp --dyno-name run.1828',
-    '$ heroku ps:stop --app myapp --process-type run',
-  ]
-
-  static args = {
-    dyno: Args.string({description: 'name of the dyno to stop', 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 stop',
-    }),
-    'process-type': flags.string({
-      char: 'p',
-      description: 'name of the process type to stop',
-      completion: ProcessTypeCompletion,
-      exclusive: ['dyno-name'],
-    }),
-  }
-
-  async run() {
-    const {args, flags} = await this.parse(Stop)
-
-    const app = flags.app
-    const dyno = flags['dyno-name'] || args.dyno
-    const type = flags['process-type']
-    let msg = 'Stopping'
-    let stopUrl = ''
-
-    if (type) {
-      msg += ` all ${color.cyan(type)} dynos`
-      stopUrl = `/apps/${app}/formations/${encodeURIComponent(type)}/actions/stop`
-    } 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)}`
-      stopUrl = `/apps/${app}/dynos/${encodeURIComponent(dyno)}/actions/stop`
-    } else {
-      ux.error(heredoc(`
-        Please specify a process type or dyno name to stop.
-        See more help with --help
-      `))
-    }
-
-    msg += ` on ${color.app(app)}`
-
-    ux.action.start(msg)
-    await this.heroku.post<Heroku.Dyno>(stopUrl, {headers: {Accept: 'application/vnd.heroku+json; version=3.sdk'}})
-    ux.action.stop()
-  }
-}
-*/

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

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

package/lib/oldCommands/ps/type.js

@@ -1,190 +0,0 @@
-export {};
-/*
-import color from '@heroku-cli/color'
-import {APIClient, Command, flags} from '@heroku-cli/command'
-import {ux} from '@oclif/core'
-import {hux} from '@heroku/heroku-cli-util'
-import * as Heroku from '@heroku-cli/schema'
-import {sortBy, compact} from 'lodash'
-import heredoc from 'tsheredoc'
-
-const COST_MONTHLY: Record<string, number> = {
-  Free: 0,
-  Eco: 0,
-  Hobby: 7,
-  Basic: 7,
-  'Standard-1X': 25,
-  'Standard-2X': 50,
-  'Performance-M': 250,
-  Performance: 500,
-  'Performance-L': 500,
-  '1X': 36,
-  '2X': 72,
-  PX: 576,
-  'Performance-L-RAM': 500,
-  'Performance-XL': 750,
-  'Performance-2XL': 1500,
-  'Private-S': 225,
-  'Private-M': 450,
-  'Private-L': 900,
-  'Shield-M': 540,
-  'Shield-L': 1080,
-  'Shield-S': 270,
-  'Private-Memory-L': 500,
-  'Private-Memory-XL': 750,
-  'Private-Memory-2XL': 1500,
-  'Shield-Memory-L': 600,
-  'Shield-Memory-XL': 900,
-  'Shield-Memory-2XL': 1800,
-  'dyno-1c-0.5gb': 25,
-  'dyno-2c-1gb': 50,
-  'dyno-1c-4gb': 80,
-  'dyno-2c-8gb': 160,
-  'dyno-4c-16gb': 320,
-  'dyno-8c-32gb': 640,
-  'dyno-16c-64gb': 1000,
-  'dyno-2c-4gb': 150,
-  'dyno-4c-8gb': 300,
-  'dyno-8c-16gb': 600,
-  'dyno-16c-32gb': 1200,
-  'dyno-32c-64gb': 2400,
-  'dyno-1c-8gb': 100,
-  'dyno-2c-16gb': 250,
-  'dyno-4c-32gb': 500,
-  'dyno-8c-64gb': 750,
-  'dyno-16c-128gb': 1500,
-}
-
-const calculateHourly =  (size: string) => COST_MONTHLY[size] / 720
-
-const emptyFormationErr = (app: string) => {
-  return new Error(`No process types on ${app}.\nUpload a Procfile to add process types.\nhttps://devcenter.heroku.com/articles/procfile`)
-}
-
-const displayFormation = async (heroku: APIClient, app: string) => {
-  const {body: formation} = await heroku.get<Heroku.Formation[]>(`/apps/${app}/formation`)
-  const {body: appProps} = await heroku.get<Heroku.App>(`/apps/${app}`)
-  const shielded = appProps.space && appProps.space.shield
-  const dynoTotals: Record<string, number> = {}
-  let isShowingEcoCostMessage = false
-
-  const formationTableData = sortBy(formation, 'type')
-    // this filter shouldn't be necessary, but it makes TS happy
-    .filter((f): f is Heroku.Formation & {size: string, quantity: number} => typeof f.size === 'string' && typeof f.quantity === 'number')
-    .map((d => {
-      if (d.size === 'Eco') {
-        isShowingEcoCostMessage = true
-      }
-
-      if (shielded) {
-        d.size = d.size.replace('Private-', 'Shield-')
-      }
-
-      if (d.size in dynoTotals) {
-        dynoTotals[d.size] += d.quantity
-      } else {
-        dynoTotals[d.size] = d.quantity
-      }
-
-      return {
-        // this rule does not realize `size` isn't used on an array
-        type: color.green(d.type || ''),
-        size: color.cyan(d.size),
-        qty: color.yellow(`${d.quantity}`),
-        'cost/hour': calculateHourly(d.size) ?
-          '~$' + (calculateHourly(d.size) * (d.quantity || 1)).toFixed(3)
-            .toString() :
-          '',
-        'max cost/month': COST_MONTHLY[d.size] ?
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore
-          '$' + (COST_MONTHLY[d.size] * d.quantity).toString() :
-          '',
-      }
-    }))
-
-  const dynoTotalsTableData = Object.keys(dynoTotals)
-    .map(k => ({
-      type: color.green(k), total: color.yellow((dynoTotals[k]).toString()),
-    }))
-
-  if (formation.length === 0) {
-    throw emptyFormationErr(app)
-  }
-
-  hux.styledHeader('Process Types')
-  hux.table(formationTableData, {
-    type: {},
-    size: {},
-    qty: {},
-    'cost/hour': {},
-    'max cost/month': {},
-  })
-  ux.log()
-  hux.styledHeader('Dyno Totals')
-  hux.table(dynoTotalsTableData, {
-    type: {},
-    total: {},
-  })
-
-  if (isShowingEcoCostMessage) {
-    ux.log('\n$5 (flat monthly fee, shared across all Eco dynos)')
-  }
-}
-
-export default class Type extends Command {
-  static strict = false
-  static description = heredoc`
-    manage dyno sizes
-    Called with no arguments shows the current dyno size.
-
-    Called with one argument sets the size.
-    Where SIZE is one of eco|basic|standard-1x|standard-2x|performance
-
-    Called with 1..n TYPE=SIZE arguments sets the quantity per type.
-  `
-  static aliases = ['ps:resize', 'dyno:resize']
-  static hiddenAliases = ['resize', 'dyno:type']
-  static flags = {
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-  }
-
-  public async run(): Promise<void> {
-    const {flags, ...restParse} = await this.parse(Type)
-    const argv = restParse.argv as string[]
-    const {app} = flags
-
-    const parse = async () => {
-      if (!argv || argv.length === 0)
-        return []
-      const {body: formation} = await this.heroku.get<Heroku.Formation[]>(`/apps/${app}/formation`)
-      if (argv.some(a => a.match(/=/))) {
-        return compact(argv.map(arg => {
-          const match = arg.match(/^([a-zA-Z0-9_]+)=([\w-]+)$/)
-          const type = match && match[1]
-          const size = match && match[2]
-          if (!type || !size || !formation.some(p => p.type === type)) {
-            throw new Error(`Type ${color.red(type || '')} not found in process formation.\nTypes: ${color.yellow(formation.map(f => f.type)
-              .join(', '))}`)
-          }
-
-          return {type, size}
-        }))
-      }
-
-      return formation.map(p => ({type: p.type, size: argv[0]}))
-    }
-
-    const changes = await parse()
-
-    if (changes.length > 0) {
-      ux.action.start(`Scaling dynos on ${color.magenta(app)}`)
-      await this.heroku.patch(`/apps/${app}/formation`, {body: {updates: changes}})
-      ux.action.stop()
-    }
-
-    await displayFormation(this.heroku, app)
-  }
-}
-*/

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

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

package/lib/oldCommands/ps/wait.js

@@ -1,93 +0,0 @@
-export {};
-/*
-import {Command, flags} from '@heroku-cli/command'
-import {ux} from '@oclif/core'
-import {hux} from '@heroku/heroku-cli-util'
-
-import {Dyno, Release} from '@heroku-cli/schema'
-
-export default class Wait extends Command {
-  static description = 'wait for all dynos to be running latest version after a release'
-
-  static flags = {
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-    type: flags.string({
-      char: 't',
-      description: 'wait for one specific dyno type',
-    }),
-    'wait-interval': flags.integer({
-      char: 'w',
-      description: 'how frequently to poll in seconds (to avoid hitting Heroku API rate limits)',
-      parse: async input => {
-        const w = Number.parseInt(input, 10)
-        if (w < 10) {
-          ux.error('wait-interval must be at least 10', {exit: 1})
-        }
-
-        return w
-      },
-      default: 10,
-    }),
-    'with-run': flags.boolean({
-      char: 'R',
-      description: 'whether to wait for one-off run dynos',
-      exclusive: ['type'],
-    }),
-  }
-
-  async run() {
-    const {flags} = await this.parse(Wait)
-
-    const {body: releases} = await this.heroku.request<Release[]>(`/apps/${flags.app}/releases`, {
-      partial: true,
-      headers: {
-        Range: 'version ..; max=1, order=desc',
-      },
-    })
-
-    if (releases.length === 0) {
-      this.warn(`App ${flags.app} has no releases`)
-      return
-    }
-
-    const latestRelease = releases[0]
-
-    let released = true
-    const interval = flags['wait-interval'] as number
-
-    while (1 as any) {
-      const {body: dynos} = await this.heroku.get<Dyno[]>(`/apps/${flags.app}/dynos`)
-      const relevantDynos = dynos
-        .filter(dyno => dyno.type !== 'release')
-        .filter(dyno => flags['with-run'] || dyno.type !== 'run')
-        .filter(dyno => !flags.type || dyno.type === flags.type)
-
-      const onLatest = relevantDynos.filter((dyno: Dyno) => {
-        return dyno.state === 'up' &&
-          latestRelease.version !== undefined &&
-          dyno.release !== undefined &&
-          dyno.release.version !== undefined &&
-          dyno.release.version >= latestRelease.version
-      })
-      const releasedFraction = `${onLatest.length} / ${relevantDynos.length}`
-      if (onLatest.length === relevantDynos.length) {
-        if (!released) {
-          ux.action.stop(`${releasedFraction}, done`)
-        }
-
-        break
-      }
-
-      if (released) {
-        released = false
-        ux.action.start(`Waiting for every dyno to be running v${latestRelease.version}`)
-      }
-
-      ux.action.status = releasedFraction
-
-      await hux.wait(interval * 1000)
-    }
-  }
-}
-*/

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

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

package/lib/oldCommands/releases/index.js

@@ -1,156 +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 {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

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

package/lib/oldCommands/releases/info.js

@@ -1,68 +0,0 @@
-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

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

package/lib/oldCommands/releases/output.js

@@ -1,42 +0,0 @@
-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

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