heroku 10.13.2 → 11.0.0-alpha.2

package/lib/oldCommands/autocomplete/script.js

@@ -0,0 +1,35 @@
+export {};
+/*
+import {Args} from '@oclif/core'
+import * as path from 'path'
+
+import {AutocompleteBase} from '../../lib/autocomplete/base'
+
+export default class Script extends AutocompleteBase {
+  static description = 'display autocomplete setup script for shell'
+
+  static hidden = true
+
+  static args = {
+    shell: Args.string({description: 'shell type', required: false}),
+  }
+
+  async run() {
+    const {args} = await this.parse(Script)
+    const shell = args.shell || this.config.shell
+    this.errorIfNotSupportedShell(shell)
+
+    const shellUpcase = shell.toUpperCase()
+    this.log(
+      `${this.prefix}HEROKU_AC_${shellUpcase}_SETUP_PATH=${path.join(
+        this.autocompleteCacheDir,
+        `${shell}_setup`,
+      )} && test -f $HEROKU_AC_${shellUpcase}_SETUP_PATH && source $HEROKU_AC_${shellUpcase}_SETUP_PATH;`,
+    )
+  }
+
+  private get prefix(): string {
+    return `\n# ${this.config.bin} autocomplete setup\n`
+  }
+}
+*/

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

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

package/lib/oldCommands/local/index.js

@@ -0,0 +1,91 @@
+export {};
+/*
+import {FileCompletion} from '@heroku-cli/command/lib/completions'
+import {Args, Command, Flags} from '@oclif/core'
+import * as fs from 'fs'
+import color from '@heroku-cli/color'
+import {fork as foreman} from '../../lib/local/fork-foreman'
+
+// eslint-disable-next-line node/no-missing-require
+const Procfile: any = require('../../lib/local/load-foreman-procfile')
+
+export default class Index extends Command {
+  // \n splits the description between the title shown in the help
+  // and the DESCRIPTION section shown in the help
+  static description = 'run heroku app locally\nStart the application specified by a Procfile (defaults to ./Procfile)'
+
+  static aliases = ['local:start']
+
+  static args = {
+    processname: Args.string({required: false, description: 'name of the process'}),
+  }
+
+  static examples = [
+    `$ heroku local
+$ heroku local web
+$ heroku local web=2
+$ heroku local web=1,worker=2`,
+  ]
+
+  static flags = {
+    procfile: Flags.string({
+      char: 'f',
+      description: 'use a different Procfile',
+      completion: FileCompletion,
+    }),
+    env: Flags.string({
+      char: 'e',
+      description: 'location of env file (defaults to .env)',
+      completion: FileCompletion,
+    }),
+    port: Flags.string({
+      char: 'p',
+      description: 'port to listen on',
+    }),
+    restart: Flags.boolean({
+      char: 'r',
+      description: 'restart process if it dies',
+      hidden: true,
+    }),
+    concurrency: Flags.string({
+      char: 'c',
+      description: 'number of processes to start',
+      hidden: true,
+    }),
+  }
+
+  async run() {
+    const execArgv = ['start']
+    const {args, flags} = await this.parse(Index)
+
+    if (flags.restart) {
+      this.error('--restart is no longer available\nUse forego instead: https://github.com/ddollar/forego')
+    }
+
+    if (flags.concurrency) {
+      this.error('--concurrency is no longer available\nUse forego instead: https://github.com/ddollar/forego')
+    }
+
+    let envFile = flags.env || '.env'
+    if (fs.existsSync(envFile) && !fs.statSync(envFile).isFile()) {
+      this.warn(`The specified location for the env file, ${color.bold(envFile)}, is not a file, ignoring.`)
+      envFile = ''
+    }
+
+    if (flags.procfile) execArgv.push('--procfile', flags.procfile)
+    execArgv.push('--env', envFile)
+    if (flags.port) execArgv.push('--port', flags.port)
+
+    if (args.processname) {
+      execArgv.push(args.processname)
+    } else {
+      const procfile = flags.procfile || 'Procfile'
+      const procHash = Procfile.loadProc(procfile)
+      const processes = Object.keys(procHash).filter(x => x !== 'release')
+      execArgv.push(processes.join(','))
+    }
+
+    await foreman(execArgv)
+  }
+}
+*/

package/lib/oldCommands/local/run.d.ts

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

package/lib/oldCommands/local/run.js

@@ -0,0 +1,54 @@
+export {};
+/*
+import {FileCompletion} from '@heroku-cli/command/lib/completions'
+import {Command, Flags} from '@oclif/core'
+import color from '@heroku-cli/color'
+import {fork as foreman} from '../../lib/local/fork-foreman'
+import {revertSortedArgs} from '../../lib/run/helpers'
+import * as fs from 'fs'
+
+export default class Run extends Command {
+  static description = 'run a one-off command'
+
+  static examples = [
+    '$ heroku local:run bin/migrate',
+  ]
+
+  static strict = false
+
+  static flags = {
+    env: Flags.string({
+      char: 'e',
+      completion: FileCompletion,
+    }),
+    port: Flags.string({
+      char: 'p',
+    }),
+  }
+
+  async run() {
+    const execArgv: string[] = ['run']
+    const {argv, flags} = await this.parse(Run)
+    const commandArgs = revertSortedArgs(process.argv, argv as string[])
+
+    if (commandArgs.length === 0) {
+      const errorMessage = 'Usage: heroku local:run [COMMAND]\nMust specify command to run'
+      this.error(errorMessage, {exit: -1})
+    }
+
+    let envFile = flags.env || '.env'
+    if (fs.existsSync(envFile) && !fs.statSync(envFile).isFile()) {
+      this.warn(`The specified location for the env file, ${color.bold(envFile)}, is not a file, ignoring.`)
+      envFile = ''
+    }
+
+    execArgv.push('--env', envFile)
+    if (flags.port) execArgv.push('--port', flags.port)
+
+    execArgv.push('--') // disable node-foreman flag parsing
+    execArgv.push(...commandArgs as string[]) // eslint-disable-line unicorn/no-array-push-push
+
+    await foreman(execArgv)
+  }
+}
+*/

package/lib/oldCommands/local/version.d.ts

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

package/lib/oldCommands/local/version.js

@@ -0,0 +1,17 @@
+export {};
+/*
+import {Command} from '@oclif/core'
+
+import {fork as foreman} from '../../lib/local/fork-foreman'
+
+export default class Version extends Command {
+  static description = 'display node-foreman version'
+
+  async run() {
+    await this.parse(Version)
+
+    const execArgv = ['--version']
+    await foreman(execArgv)
+  }
+}
+*/

package/lib/oldCommands/members/add.d.ts

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

package/lib/oldCommands/members/add.js

@@ -0,0 +1,36 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+import {RoleCompletion} from '@heroku-cli/command/lib/completions'
+import {addMemberToTeam, inviteMemberToTeam} from '../../lib/members/util'
+export default class MembersAdd extends Command {
+    static topic = 'members';
+    static description = 'adds a user to a team';
+    static flags = {
+      role: flags.string({char: 'r', required: true, description: 'member role (admin, collaborator, member, owner)', completion: RoleCompletion}),
+      team: flags.team({required: true}),
+    };
+
+    static args = {
+      email: Args.string({required: true, description: 'email address of the team member'}),
+    };
+
+    public async run(): Promise<void> {
+      const {flags, args} = await this.parse(MembersAdd)
+      const {team, role} = flags
+      const {body: teamInfo} = await this.heroku.get<Heroku.Team>(`/teams/${team}`)
+      const email = args.email
+      const {body: groupFeatures} = await this.heroku.get<Heroku.TeamFeature[]>(`/teams/${team}/features`)
+
+      if (teamInfo.type === 'team' && groupFeatures.some(feature => {
+        return feature.name === 'team-invite-acceptance' && feature.enabled
+      })) {
+        await inviteMemberToTeam(email, role, team, this.heroku)
+      } else {
+        await addMemberToTeam(email, role, team, this.heroku)
+      }
+    }
+}
+*/

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

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

package/lib/oldCommands/members/index.js

@@ -0,0 +1,92 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {RoleCompletion} from '@heroku-cli/command/lib/completions'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import * as Heroku from '@heroku-cli/schema'
+
+const _ = require('lodash')
+
+type MemberWithStatus = Heroku.TeamMember & { status?: string }
+
+const buildTableColumns = (teamInvites: Heroku.TeamInvitation[]) => {
+  const baseColumns = {
+    email: {
+      get: ({email}: any):string => color.cyan(email),
+    },
+    role: {
+      get: ({role}: any):string => color.green(role),
+    },
+  }
+
+  if (teamInvites.length > 0) {
+    return {
+      ...baseColumns,
+      status: {
+        get: ({status}: any):string => color.green(status),
+      },
+    }
+  }
+
+  return baseColumns
+}
+
+export default class MembersIndex extends Command {
+    static topic = 'members';
+    static description = 'list members of a team';
+    static flags = {
+      role: flags.string({char: 'r', description: 'filter by role', completion: RoleCompletion}),
+      pending: flags.boolean({description: 'filter by pending team invitations'}),
+      json: flags.boolean({description: 'output in json format'}),
+      team: flags.team({required: true}),
+    };
+
+    public async run(): Promise<void> {
+      const {flags} = await this.parse(MembersIndex)
+      const {role, pending, json, team} = flags
+      const {body: teamInfo} = await this.heroku.get<Heroku.Team>(`/teams/${team}`)
+      let teamInvites: Heroku.TeamInvitation[] = []
+      if (teamInfo.type === 'team') {
+        const {body: orgFeatures} = await this.heroku.get<Heroku.TeamFeature[]>(`/teams/${team}/features`)
+        if (orgFeatures.some((feature => feature.name === 'team-invite-acceptance' && feature.enabled))) {
+          const invitesResponse = await this.heroku.get<Heroku.TeamInvitation[]>(
+            `/teams/${team}/invitations`,
+            {headers: {
+              Accept: 'application/vnd.heroku+json; version=3.team-invitations',
+            },
+            })
+          teamInvites = _.map(invitesResponse.body, function (invite: Heroku.TeamInvitation) {
+            return {email: invite.user?.email, role: invite.role, status: 'pending'}
+          })
+        }
+      }
+
+      let {body: members} = await this.heroku.get<MemberWithStatus[]>(`/teams/${team}/members`)
+      // Set status '' to all existing members
+      _.map(members, (member: MemberWithStatus) => {
+        member.status = ''
+      })
+      members = _.sortBy(_.union(members, teamInvites), 'email')
+      if (role)
+        members = members.filter(m => m.role === role)
+      if (pending)
+        members = members.filter(m => m.status === 'pending')
+      if (json) {
+        ux.log(JSON.stringify(members, null, 3))
+      } else if (members.length === 0) {
+        let msg = `No members in ${color.magenta(team || '')}`
+        if (role)
+          msg += ` with role ${color.green(role)}`
+        ux.log(msg)
+      } else {
+        const tableColumns = buildTableColumns(teamInvites)
+        hux.table(
+          members,
+          tableColumns,
+        )
+      }
+    }
+}
+*/

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

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

package/lib/oldCommands/members/remove.js

@@ -0,0 +1,70 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {APIClient, Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+
+const revokeInvite = async (email: string, team: string, heroku: APIClient) => {
+  ux.action.start(`Revoking invite for ${color.cyan(email)} in ${color.magenta(team)}`)
+  await heroku.delete<Heroku.TeamInvitation[]>(
+    `/teams/${team}/invitations/${email}`,
+    {
+      headers: {
+        Accept: 'application/vnd.heroku+json; version=3.team-invitations',
+      },
+    })
+  ux.action.stop()
+}
+
+const getTeamInvites = async (team: string, heroku: APIClient) => {
+  const {body: teamInvites} = await heroku.get<Heroku.TeamInvitation[]>(
+    `/teams/${team}/invitations`,
+    {
+      headers: {
+        Accept: 'application/vnd.heroku+json; version=3.team-invitations',
+      },
+    })
+  return teamInvites
+}
+
+const removeUserMembership = async (email:string, team: string, heroku: APIClient) => {
+  ux.action.start(`Removing ${color.cyan(email)} from ${color.magenta(team)}`)
+  await heroku.delete(`/teams/${team}/members/${encodeURIComponent(email)}`)
+  ux.action.stop()
+}
+
+export default class MembersRemove extends Command {
+  static topic = 'members';
+  static description = 'removes a user from a team';
+  static flags = {
+    team: flags.team({required: true}),
+  };
+
+  static strict = false
+
+  public async run(): Promise<void> {
+    const {flags, argv} = await this.parse(MembersRemove)
+    const {team} = flags
+    const email = argv[0] as string
+    const {body: teamInfo} = await this.heroku.get<Heroku.Team>(`/teams/${team}`)
+    let teamInviteFeatureEnabled = false
+    let isInvitedUser = false
+
+    if (teamInfo.type === 'team') {
+      const {body: teamFeatures} = await this.heroku.get<Heroku.TeamFeature[]>(`/teams/${team}/features`)
+      teamInviteFeatureEnabled = Boolean(teamFeatures.some(feature => feature.name === 'team-invite-acceptance' && feature.enabled))
+      if (teamInviteFeatureEnabled) {
+        const invites = await getTeamInvites(team, this.heroku)
+        isInvitedUser = Boolean(invites.some(m => m.user?.email === email))
+      }
+    }
+
+    if (teamInviteFeatureEnabled && isInvitedUser) {
+      await revokeInvite(email, team, this.heroku)
+    } else {
+      await removeUserMembership(email, team, this.heroku)
+    }
+  }
+}
+*/

package/lib/oldCommands/members/set.d.ts

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

package/lib/oldCommands/members/set.js

@@ -0,0 +1,24 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {RoleCompletion} from '@heroku-cli/command/lib/completions'
+import {addMemberToTeam} from '../../lib/members/utils'
+
+export default class MembersSet extends Command {
+  static topic = 'members'
+  static description = 'sets a members role in a team'
+  static strict = false
+  static flags = {
+    role: flags.string({char: 'r', required: true, description: 'member role (admin, collaborator, member, owner)', completion: RoleCompletion}),
+    team: flags.team({required: true}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, argv} = await this.parse(MembersSet)
+    const {role, team} = flags
+    const email = argv[0] as string
+
+    await addMemberToTeam(email, role, team, this.heroku, 'PATCH')
+  }
+}
+*/

package/lib/oldCommands/pg/backups/cancel.d.ts

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

package/lib/oldCommands/pg/backups/cancel.js

@@ -0,0 +1,56 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import host from '../../../lib/pg/host'
+import backupsFactory from '../../../lib/pg/backups'
+import {BackupTransfer} from '../../../lib/pg/types'
+
+export default class Cancel extends Command {
+  static topic = 'pg'
+  static description = 'cancel an in-progress backup or restore (default newest)'
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    backup_id: Args.string({description: 'ID of the backup. If omitted, we use the last unfinished backup ID.'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Cancel)
+    const {app} = flags
+    const {backup_id} = args
+    const pgbackups = backupsFactory(app, this.heroku)
+
+    let transfer: BackupTransfer | undefined
+
+    if (backup_id) {
+      const num = await pgbackups.num(backup_id)
+      if (!num) {
+        ux.error(`Invalid Backup: ${backup_id}`)
+      }
+
+      ({body: transfer} = await this.heroku.get<BackupTransfer>(`/client/v11/apps/${app}/transfers/${num}`, {hostname: host()}))
+    } else {
+      const {body: transfers} = await this.heroku.get<BackupTransfer[]>(`/client/v11/apps/${app}/transfers`, {hostname: host()})
+      transfer = this.sortByCreatedAtDesc(transfers).find(t => !t.finished_at)
+    }
+
+    if (transfer) {
+      ux.action.start(`Cancelling ${pgbackups.name(transfer)}`)
+      this.heroku.post(`/client/v11/apps/${app}/transfers/${transfer.uuid}/actions/cancel`, {hostname: host()})
+      ux.action.stop()
+    } else {
+      ux.error('No active backups/transfers')
+    }
+  }
+
+  protected sortByCreatedAtDesc(transfers: BackupTransfer[]): BackupTransfer[] {
+    return transfers.sort((a, b) => {
+      return new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
+    })
+  }
+}
+*/

package/lib/oldCommands/pg/backups/capture.d.ts

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

package/lib/oldCommands/pg/backups/capture.js

@@ -0,0 +1,77 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import backupsApi from '../../../lib/pg/backups'
+import {BackupTransfer, PgDatabase} from '../../../lib/pg/types'
+import {getAddon} from '../../../lib/pg/fetcher'
+import pgHost from '../../../lib/pg/host'
+import heredoc from 'tsheredoc'
+import {HTTPError} from '@heroku/http-call'
+import {nls} from '../../../nls'
+
+export default class Capture extends Command {
+  static topic = 'pg';
+  static description = 'capture a new backup';
+  static flags = {
+    'wait-interval': flags.string(),
+    verbose: flags.boolean({char: 'v'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  };
+
+  static args = {
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+  };
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Capture)
+    const {app, 'wait-interval': waitInterval, verbose} = flags
+    const {database} = args
+
+    const interval = Math.max(3, Number.parseInt(waitInterval || '3', 10))
+    const db = await getAddon(this.heroku, app, database)
+    const pgBackupsApi = backupsApi(app, this.heroku)
+
+    try {
+      const {body: dbInfo} = await this.heroku.get<PgDatabase>(`/client/v11/databases/${db.id}`, {hostname: pgHost()})
+      const dbProtected = /On/.test(dbInfo.info.find(attribute => attribute.name === 'Continuous Protection')?.values[0] || '')
+      if (dbProtected) {
+        ux.warn('Continuous protection is already enabled for this database. Logical backups of large databases are likely to fail.')
+        ux.warn('See https://devcenter.heroku.com/articles/heroku-postgres-data-safety-and-continuous-protection#physical-backups-on-heroku-postgres.')
+      }
+    } catch (error: unknown) {
+      const httpError = error as HTTPError
+      if (httpError.statusCode !== 404)
+        throw httpError
+      ux.error(
+        heredoc`
+          ${color.yellow(db.name)} is not yet provisioned.
+          Run ${color.cmd('heroku addons:wait')} to wait until the db is provisioned.
+        `,
+        {exit: 1},
+      )
+    }
+
+    ux.action.start(`Starting backup of ${color.yellow(db.name)}`)
+    const {body: backup} = await this.heroku.post<BackupTransfer>(`/client/v11/databases/${db.id}/backups`, {hostname: pgHost()})
+    ux.action.stop()
+    ux.log(heredoc`
+
+      Use Ctrl-C at any time to stop monitoring progress; the backup will continue running.
+      Use ${color.cmd('heroku pg:backups:info')} to check progress.
+      Stop a running backup with ${color.cmd('heroku pg:backups:cancel')}.
+    `)
+
+    if (app !== db.app.name) {
+      ux.log(heredoc`
+        HINT: You are running this command with a non-billing application.
+        Use ${color.cmd('heroku pg:backups -a ' + db.app.name)} to check the list of backups.
+      `)
+    }
+
+    await pgBackupsApi.wait(`Backing up ${color.green(backup.from_name)} to ${color.cyan(pgBackupsApi.name(backup))}`, backup.uuid, interval, verbose, db.app.name || app)
+  }
+}
+*/

package/lib/oldCommands/pg/backups/delete.d.ts

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

package/lib/oldCommands/pg/backups/delete.js

@@ -0,0 +1,45 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import confirmCommand from '../../../lib/confirmCommand'
+import host from '../../../lib/pg/host'
+import backupsFactory from '../../../lib/pg/backups'
+
+export default class Delete extends Command {
+  static topic = 'pg'
+  static description = 'delete a backup'
+  static flags = {
+    confirm: flags.string({char: 'c'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    backup_id: Args.string({required: true, description: 'ID of the backup'}),
+  }
+
+  static examples = [
+    '$ heroku pg:backup:delete --app APP_ID BACKUP_ID',
+  ]
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Delete)
+    const {app, confirm} = flags
+    const {backup_id} = args
+    const pgbackups = backupsFactory(app, this.heroku)
+
+    await confirmCommand(app, confirm)
+    ux.action.start(`Deleting backup ${color.cyan(backup_id)} on ${color.app(app)}`)
+
+    const num = await pgbackups.num(backup_id)
+    if (!num) {
+      throw new Error(`Invalid Backup: ${backup_id}`)
+    }
+
+    await this.heroku.delete(`/client/v11/apps/${app}/transfers/${num}`, {hostname: host()})
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/pg/backups/download.d.ts

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