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

package/lib/oldCommands/pg/wait.js

@@ -1,96 +0,0 @@
-export {};
-/*
-import color from '@heroku-cli/color'
-import {Command, flags} from '@heroku-cli/command'
-import {Args, ux} from '@oclif/core'
-import debug from 'debug'
-import {all, getAddon} from '../../lib/pg/fetcher'
-import pgHost from '../../lib/pg/host'
-import notify from '../../lib/notify'
-import {AddOnAttachmentWithConfigVarsAndPlan, AddOnWithRelatedData, PgStatus} from '../../lib/pg/types'
-import {HTTPError} from '@heroku/http-call'
-import {nls} from '../../nls'
-
-const wait = (ms: number) => new Promise(resolve => {
-  setTimeout(resolve, ms)
-})
-
-export default class Wait extends Command {
-  static topic = 'pg'
-  static description = 'blocks until database is available'
-  static flags = {
-    'wait-interval': flags.string({description: 'how frequently to poll in seconds (to avoid rate limiting)'}),
-    'no-notify': flags.boolean({description: 'do not show OS notification'}),
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-  }
-
-  static args = {
-    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:all-dbs:suffix')}`}),
-  }
-
-  public async run(): Promise<void> {
-    const {flags, args} = await this.parse(Wait)
-    const {app, 'wait-interval': waitInterval} = flags
-    const dbName = args.database
-    const pgDebug = debug('pg')
-
-    const waitFor = async (db: AddOnAttachmentWithConfigVarsAndPlan | AddOnWithRelatedData) => {
-      let interval = waitInterval && Number.parseInt(waitInterval, 10)
-      if (!interval || interval < 0) interval = 5
-      let status
-      let waiting = false
-      let retries = 20
-      const notFoundMessage = 'Waiting to provision...'
-
-      while (true) {
-        try {
-          ({body: status} = await this.heroku.get<PgStatus>(
-            `/client/v11/databases/${db.id}/wait_status`,
-            {hostname: pgHost()},
-          ))
-        } catch (error) {
-          const httpError = error as HTTPError
-          pgDebug(httpError)
-          if (!retries || httpError.statusCode !== 404) throw httpError
-          retries--
-          status = {'waiting?': true, message: notFoundMessage}
-        }
-
-        if (status['error?']) {
-          notify('error', `${db.name} ${status.message}`, false)
-          ux.error(status.message || '', {exit: 1})
-        }
-
-        if (!status['waiting?']) {
-          if (waiting) {
-            ux.action.stop(status.message)
-          }
-
-          return
-        }
-
-        if (!waiting) {
-          waiting = true
-          ux.action.start(`Waiting for database ${color.yellow(db.name)}`, status.message)
-        }
-
-        ux.action.status = status.message
-
-        await wait(interval * 1000)
-      }
-    }
-
-    let dbs: AddOnAttachmentWithConfigVarsAndPlan[] | AddOnWithRelatedData[] | [] = []
-    if (dbName) {
-      dbs = [await getAddon(this.heroku, app, dbName)]
-    } else {
-      dbs = await all(this.heroku, app)
-    }
-
-    for (const db of dbs) {
-      await waitFor(db)
-    }
-  }
-}
-*/

package/lib/oldCommands/pipelines/open.d.ts

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

package/lib/oldCommands/pipelines/open.js

@@ -1,25 +0,0 @@
-export {};
-/*
-import {Command} from '@heroku-cli/command'
-import {Args} from '@oclif/core'
-import * as open from 'open'
-
-import disambiguate from '../../lib/pipelines/disambiguate'
-
-export default class Open extends Command {
-  static description = 'open a pipeline in dashboard'
-
-  static examples = ['$ heroku pipelines:open my-pipeline']
-
-  static args = {
-    pipeline: Args.string({description: 'name of pipeline', required: true}),
-  }
-
-  async run() {
-    const {args} = await this.parse(Open)
-
-    const pipeline: any = await disambiguate(this.heroku, args.pipeline)
-    await open(`https://dashboard.heroku.com/pipelines/${pipeline.id}`)
-  }
-}
-*/

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

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

package/lib/oldCommands/pipelines/promote.js

@@ -1,269 +0,0 @@
-export {};
-/*
-import color from '@heroku-cli/color'
-import {APIClient, Command, flags} from '@heroku-cli/command'
-import * as Heroku from '@heroku-cli/schema'
-import {ux} from '@oclif/core'
-import {hux} from '@heroku/heroku-cli-util'
-import * as assert from 'assert'
-import fetch from 'node-fetch'
-import * as Stream from 'stream'
-import * as util from 'util'
-
-import {AppWithPipelineCoupling, listPipelineApps} from '../../lib/api'
-import keyBy from '../../lib/pipelines/key-by'
-
-export const sleep  = (time: number) => {
-  return new Promise(resolve => setTimeout(resolve, time))
-}
-
-function assertNotPromotingToSelf(source: string, target: string) {
-  assert.notStrictEqual(source, target, `Cannot promote from an app to itself: ${target}. Specify a different target app.`)
-}
-
-function findAppInPipeline(apps: Array<AppWithPipelineCoupling>, target: string) {
-  const found = apps.find(app => (app.name === target) || (app.id === target))
-  assert(found, `Cannot find app ${color.app(target)}`)
-
-  return found
-}
-
-const PROMOTION_ORDER = ['development', 'staging', 'production']
-
-const wait = (ms = 100) => new Promise(resolve => setTimeout(resolve, ms))
-
-function isComplete(promotionTarget: Heroku.PipelinePromotionTarget) {
-  return promotionTarget.status !== 'pending'
-}
-
-function isSucceeded(promotionTarget: Heroku.PipelinePromotionTarget) {
-  return promotionTarget.status === 'succeeded'
-}
-
-function isFailed(promotionTarget: Heroku.PipelinePromotionTarget) {
-  return promotionTarget.status === 'failed'
-}
-
-function pollPromotionStatus(heroku: APIClient, id: string, needsReleaseCommand: boolean): Promise<Array<Heroku.PipelinePromotionTarget>> {
-  return heroku.get<Array<Heroku.PipelinePromotionTarget>>(`/pipeline-promotions/${id}/promotion-targets`).then(function ({body: targets}) {
-    if (targets.every(isComplete)) {
-      return targets
-    }
-
-    //
-    // With only one target, we can return as soon as the release is created.
-    // The command will then read the release phase output
-    //
-    // `needsReleaseCommand` allows us to keep polling, as it can take a few
-    // seconds to get the release to succeeded after the release command
-    // finished.
-    //
-    if (needsReleaseCommand && targets.length === 1 && targets[0].release !== null) {
-      return targets
-    }
-
-    return wait(1000).then(pollPromotionStatus.bind(null, heroku, id, needsReleaseCommand))
-  })
-}
-
-async function getCoupling(heroku: APIClient, app: string): Promise<Heroku.PipelineCoupling> {
-  ux.log('Fetching app info...')
-  const {body: coupling} = await heroku.get<Heroku.PipelineCoupling>(`/apps/${app}/pipeline-couplings`)
-  return coupling
-}
-
-async function promote(heroku: APIClient, label: string, id: string, sourceAppId: string, targetApps: Array<AppWithPipelineCoupling>, secondFactor?: string): Promise<Heroku.PipelinePromotion> {
-  const options = {
-    headers: {},
-    body: {
-      pipeline: {id},
-      source: {app: {id: sourceAppId}},
-      targets: targetApps.map(app => ({app: {id: app.id}})),
-    },
-  }
-
-  if (secondFactor) {
-    options.headers = {'Heroku-Two-Factor-Code': secondFactor}
-  }
-
-  try {
-    ux.log(`${label}...`)
-    const {body: promotions} = await heroku.post<Heroku.PipelinePromotion>('/pipeline-promotions', options)
-    return promotions
-  } catch (error: any) {
-    if (!error.body || error.body.id !== 'two_factor') {
-      throw error
-    }
-
-    const secondFactor = await heroku.twoFactorPrompt()
-    return promote(heroku, label, id, sourceAppId, targetApps, secondFactor)
-  }
-}
-
-function assertValidPromotion(app: string, source: string, target?: string) {
-  if (!target || PROMOTION_ORDER.indexOf(source) < 0) { // eslint-disable-line unicorn/prefer-includes
-    throw new Error(`Cannot promote ${app} from '${source}' stage`)
-  }
-}
-
-function assertApps(app: string, targetApps: Array<AppWithPipelineCoupling>, targetStage: string) {
-  if (targetApps.length === 0) {
-    throw new Error(`Cannot promote from ${color.app(app)} as there are no downstream apps in ${targetStage} stage`)
-  }
-}
-
-async function getRelease(heroku: APIClient, app: string, releaseId: string): Promise<Heroku.Release> {
-  ux.log('Fetching release info...')
-  const {body: release} = await heroku.get<Heroku.Release>(`/apps/${app}/releases/${releaseId}`)
-  return release
-}
-
-async function streamReleaseCommand(heroku: APIClient, targets: Array<Heroku.App>, promotion: any) {
-  if (targets.length !== 1 || targets.every(isComplete)) {
-    return pollPromotionStatus(heroku, promotion.id, false)
-  }
-
-  const target = targets[0]
-  const release = await getRelease(heroku, target.app.id, target.release.id)
-
-  if (!release.output_stream_url) {
-    return pollPromotionStatus(heroku, promotion.id, false)
-  }
-
-  ux.log('Running release command...')
-
-  async function streamReleaseOutput(releaseStreamUrl: string) {
-    const finished = util.promisify(Stream.finished)
-    const fetchResponse = await fetch(releaseStreamUrl)
-
-    if (fetchResponse.status >= 400) {
-      throw new Error('stream release output not available')
-    }
-
-    fetchResponse.body.pipe(process.stdout)
-
-    await finished(fetchResponse.body)
-  }
-
-  async function retry(maxAttempts: number, fn: () => Promise<any>) {
-    let currentAttempt = 0
-
-    while (true) {
-      try {
-        await fn()
-        return
-      } catch (error) {
-        if (++currentAttempt === maxAttempts) {
-          throw error
-        }
-
-        await sleep(1000)
-      }
-    }
-  }
-
-  await retry(100, () => {
-    return streamReleaseOutput(release.output_stream_url!)
-  })
-
-  return pollPromotionStatus(heroku, promotion.id, false)
-}
-
-export default class Promote extends Command {
-  static description = 'promote the latest release of this app to its downstream app(s)'
-
-  static examples = [
-    '$ heroku pipelines:promote -a my-app-staging',
-  ]
-
-  static flags = {
-    app: flags.app({
-      required: true,
-    }),
-    remote: flags.remote(),
-    to: flags.string({
-      char: 't',
-      description: 'comma separated list of apps to promote to',
-    }),
-  }
-
-  async run() {
-    const {flags} = await this.parse(Promote)
-    const appNameOrId = flags.app
-    const coupling = await getCoupling(this.heroku, appNameOrId)
-    ux.log(`Fetching apps from ${color.pipeline(coupling.pipeline!.name)}...`)
-    const allApps = await listPipelineApps(this.heroku, coupling.pipeline!.id!)
-    const sourceStage = coupling.stage
-
-    let promotionActionName = ''
-    let targetApps: Array<AppWithPipelineCoupling> = []
-    if (flags.to) {
-      // The user specified a specific set of apps they want to target
-      // We don't have to infer the apps or the stage they want to promote to
-
-      // Strip out any empty app names due to something like a trailing comma
-      const targetAppNames = flags.to.split(',').filter(appName => appName.length > 0)
-
-      // Now let's make sure that we can find every target app they specified
-      // The only requirement is that the app be in this pipeline. They can be at any stage.
-      targetApps = targetAppNames.reduce((acc: Array<AppWithPipelineCoupling>, targetAppNameOrId) => {
-        assertNotPromotingToSelf(appNameOrId, targetAppNameOrId)
-        const app = findAppInPipeline(allApps, targetAppNameOrId)
-        if (app) {
-          acc.push(app)
-        }
-
-        return acc
-      }, [])
-
-      promotionActionName = `Starting promotion to apps: ${targetAppNames.toString()}`
-    } else {
-      const targetStage = PROMOTION_ORDER[PROMOTION_ORDER.indexOf(sourceStage!) + 1]
-
-      assertValidPromotion(appNameOrId, sourceStage!, targetStage)
-
-      targetApps = allApps.filter(app => app.pipelineCoupling.stage === targetStage)
-
-      assertApps(appNameOrId, targetApps, targetStage)
-
-      promotionActionName = `Starting promotion to ${targetStage}`
-    }
-
-    const promotion = await promote(
-      this.heroku, promotionActionName, coupling.pipeline!.id!, coupling.app!.id!, targetApps,
-    )
-
-    const pollLoop = pollPromotionStatus(this.heroku, promotion.id!, true)
-    ux.log('Waiting for promotion to complete...')
-    let promotionTargets = await pollLoop
-
-    try {
-      promotionTargets = await streamReleaseCommand(this.heroku, promotionTargets, promotion)
-    } catch (error: any) {
-      ux.error(error)
-    }
-
-    const appsByID = keyBy(allApps, 'id')
-
-    const styledTargets = promotionTargets.reduce(function (memo: Heroku.App, target: Heroku.App) {
-      const app = appsByID[target.app.id]
-      const details = [target.status]
-
-      if (isFailed(target)) {
-        details.push(target.error_message)
-      }
-
-      memo[app.name] = details
-      return memo
-    }, {})
-
-    if (promotionTargets.every(isSucceeded)) {
-      ux.log('\nPromotion successful')
-    } else {
-      ux.warn('\nPromotion to some apps failed')
-    }
-
-    hux.styledObject(styledTargets)
-  }
-}
-*/

package/lib/oldCommands/pipelines/remove.d.ts

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

package/lib/oldCommands/pipelines/remove.js

@@ -1,29 +0,0 @@
-export {};
-/*
-import color from '@heroku-cli/color'
-import {Command, flags} from '@heroku-cli/command'
-import {ux} from '@oclif/core'
-
-import {removeCoupling} from '../../lib/api'
-
-export default class PipelinesRemove extends Command {
-  static description = 'remove this app from its pipeline'
-
-  static examples = [
-    '$ heroku pipelines:remove -a my-app',
-  ]
-
-  static flags = {
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-  }
-
-  async run() {
-    const {flags: {app}} = await this.parse(PipelinesRemove)
-
-    ux.action.start(`Removing ${color.app(app)}`)
-    await removeCoupling(this.heroku, app)
-    ux.action.stop()
-  }
-}
-*/

package/lib/oldCommands/pipelines/rename.d.ts

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

package/lib/oldCommands/pipelines/rename.js

@@ -1,42 +0,0 @@
-export {};
-/*
-import color from '@heroku-cli/color'
-import {Command} from '@heroku-cli/command'
-import {Args, ux} from '@oclif/core'
-
-import {updatePipeline} from '../../lib/api'
-import disambiguate from '../../lib/pipelines/disambiguate'
-
-export default class PipelinesRename extends Command {
-  static description = 'rename a pipeline'
-
-  static examples = [
-    '$ heroku pipelines:rename my-pipeline new-pipeline-name',
-  ]
-
-  static args = {
-    pipeline: Args.string({
-      description: 'current name of pipeline',
-      required: true,
-    }),
-    name: Args.string({
-      description: 'new name of pipeline',
-      required: true,
-    }),
-  }
-
-  async run() {
-    const {args} = await this.parse(PipelinesRename)
-
-    const pipeline = await disambiguate(this.heroku, args.pipeline)
-
-    ux.action.start(`Renaming ${color.pipeline(pipeline.name!)} pipeline to ${color.pipeline(args.name)}`)
-
-    await updatePipeline(this.heroku, pipeline.id!, {
-      name: args.name,
-    })
-
-    ux.action.stop()
-  }
-}
-*/

package/lib/oldCommands/pipelines/setup.d.ts

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

package/lib/oldCommands/pipelines/setup.js

@@ -1,117 +0,0 @@
-export {};
-/*
-import color from '@heroku-cli/color'
-import {Command, flags} from '@heroku-cli/command'
-import {Args, ux} from '@oclif/core'
-import * as open from 'open'
-import Debug from 'debug'
-
-import {createPipeline, getAccountInfo, getTeam} from '../../lib/api'
-import GitHubAPI from '../../lib/pipelines/github-api'
-import KolkrabbiAPI from '../../lib/pipelines/kolkrabbi-api'
-import createApps from '../../lib/pipelines/setup/create-apps'
-import getCISettings from '../../lib/pipelines/setup/get-ci-settings'
-import getGitHubToken from '../../lib/pipelines/setup/get-github-token'
-import getNameAndRepo from '../../lib/pipelines/setup/get-name-and-repo'
-import getRepo from '../../lib/pipelines/setup/get-repo'
-import getSettings from '../../lib/pipelines/setup/get-settings'
-import pollAppSetups from '../../lib/pipelines/setup/poll-app-setups'
-import setupPipeline from '../../lib/pipelines/setup/setup-pipeline'
-import {nameAndRepo, STAGING_APP_INDICATOR} from '../../lib/pipelines/setup/validate'
-
-// eslint-disable-next-line new-cap
-const debug = Debug('pipelines:setup')
-
-export default class Setup extends Command {
-  static description =
-    'bootstrap a new pipeline with common settings and create a production and staging app (requires a fully formed app.json in the repo)'
-
-  static examples = ['$ heroku pipelines:setup my-pipeline githuborg/reponame -t my-team']
-
-  static flags = {
-    team: flags.team({
-      description: 'the team to assign pipeline ownership to (defaults to current user)',
-    }),
-
-    yes: flags.boolean({
-      char: 'y',
-      description: 'accept all default settings without prompting',
-    }),
-  }
-
-  static args = {
-    name: Args.string({
-      description: 'name of pipeline',
-      required: false,
-    }),
-    repo: Args.string({
-      description: 'a GitHub repository to connect the pipeline to',
-      required: false,
-    }),
-  }
-
-  async run() {
-    const {args, flags} = await this.parse(Setup)
-
-    const errors = nameAndRepo(args)
-
-    if (errors.length > 0) {
-      this.error(errors.join(', '))
-      return
-    }
-
-    const kolkrabbi = new KolkrabbiAPI(this.config.userAgent, () => this.heroku.auth)
-    const github = new GitHubAPI(this.config.userAgent, await getGitHubToken(kolkrabbi))
-
-    const team = flags.team
-
-    const {name: pipelineName, repo: repoName} = await getNameAndRepo(args)
-    const stagingAppName = pipelineName + STAGING_APP_INDICATOR
-    const repo = await getRepo(github, repoName)
-    const settings = await getSettings(flags.yes, repo.default_branch)
-
-    const ciSettings = await getCISettings(flags.yes, team)
-    const ownerType = team ? 'team' : 'user'
-
-    // If team or org is not specified, we assign ownership to the user creating
-    const {
-      body: {id: ownerID},
-    }: any = team ? await getTeam(this.heroku, team) : await getAccountInfo(this.heroku)
-    const owner = {id: ownerID, type: ownerType}
-
-    ux.action.start('Creating pipeline')
-    const {body: pipeline}: any = await createPipeline(this.heroku, pipelineName, owner)
-    ux.action.stop()
-
-    ux.action.start('Linking to repo')
-    await kolkrabbi.createPipelineRepository(pipeline.id, repo.id)
-    ux.action.stop()
-
-    const archiveURL = await kolkrabbi.getArchiveURL(repoName, repo.default_branch)
-
-    const appSetupsResult: any = await createApps(this.heroku, archiveURL, pipeline, pipelineName, stagingAppName, team)
-    const appSetups = appSetupsResult.map((result: any) => result.body)
-
-    ux.action.start(
-      `Creating production and staging apps (${color.app(pipelineName)} and ${color.app(stagingAppName)})`,
-    )
-    await pollAppSetups(this.heroku, appSetups)
-    ux.action.stop()
-
-    const stagingApp = appSetups.find((appSetup: any) => appSetup.app.name === stagingAppName).app
-
-    const setup = setupPipeline(kolkrabbi, stagingApp.id, settings, pipeline.id, ciSettings)
-
-    ux.action.start('Configuring pipeline')
-    try {
-      await setup
-      await open(`https://dashboard.heroku.com/pipelines/${pipeline.id}`)
-    } catch (error: any) {
-      debug(error)
-      ux.error(error)
-    } finally {
-      ux.action.stop()
-    }
-  }
-}
-*/

package/lib/oldCommands/pipelines/transfer.d.ts

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

package/lib/oldCommands/pipelines/transfer.js

@@ -1,78 +0,0 @@
-export {};
-/*
-import color from '@heroku-cli/color'
-import {APIClient, Command, flags} from '@heroku-cli/command'
-import {Args, ux} from '@oclif/core'
-import {hux} from '@heroku/heroku-cli-util'
-
-import {createPipelineTransfer, getAccountInfo, getTeam, listPipelineApps} from '../../lib/api'
-import disambiguate from '../../lib/pipelines/disambiguate'
-import renderPipeline from '../../lib/pipelines/render-pipeline'
-
-async function getTeamOwner(heroku: APIClient, name: string) {
-  const {body: team} = await getTeam(heroku, name)
-  return {id: team.id, type: 'team'}
-}
-
-async function getAccountOwner(heroku: APIClient, name: string) {
-  const {body: account} = await getAccountInfo(heroku, name)
-  return {id: account.id, type: 'user'}
-}
-
-function getOwner(heroku: APIClient, name: string) {
-  return getTeamOwner(heroku, name)
-    .catch(() => {
-      return getAccountOwner(heroku, name)
-    })
-    .catch(() => {
-      throw new Error(`Cannot find a team or account for "${name}"`)
-    })
-}
-
-export default class PipelinesTransfer extends Command {
-  static description = 'transfer ownership of a pipeline'
-
-  static examples = [
-    '$ heroku pipelines:transfer admin@example.com -p my-pipeline',
-    '$ heroku pipelines:transfer admin-team -p my-pipeline',
-  ]
-
-  static args = {
-    owner: Args.string({
-      description: 'the owner to transfer the pipeline to',
-      required: true,
-    }),
-  }
-
-  static flags = {
-    pipeline: flags.pipeline({required: true}),
-    confirm: flags.string({char: 'c'}),
-  }
-
-  async run() {
-    const {args, flags} = await this.parse(PipelinesTransfer)
-    const pipeline = await disambiguate(this.heroku, flags.pipeline)
-    const newOwner = await getOwner(this.heroku, args.owner)
-    const apps = await listPipelineApps(this.heroku, pipeline.id!)
-    const displayType = newOwner.type === 'user' ? 'account' : newOwner.type
-    let confirmName = flags.confirm
-
-    if (!confirmName) {
-      await renderPipeline(this.heroku, pipeline, apps)
-      ux.log('')
-      ux.warn(`This will transfer ${color.pipeline(pipeline.name!)} and all of the listed apps to the ${args.owner} ${displayType}`)
-      ux.warn(`to proceed, type ${color.red(pipeline.name!)} or re-run this command with ${color.red('--confirm')} ${pipeline.name}`)
-      confirmName = await hux.prompt('', {})
-    }
-
-    if (confirmName !== pipeline.name) {
-      ux.warn(`Confirmation did not match ${color.red(pipeline.name!)}. Aborted.`)
-      return
-    }
-
-    ux.action.start(`Transferring ${color.pipeline(pipeline.name!)} pipeline to the ${args.owner} ${displayType}`)
-    await createPipelineTransfer(this.heroku, {pipeline: {id: pipeline.id}, new_owner: newOwner})
-    ux.action.stop()
-  }
-}
-*/

package/lib/oldCommands/pipelines/update.d.ts

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