heroku 10.13.2 → 11.0.0-alpha.2

package/lib/oldCommands/pg/upgrade/run.js

@@ -0,0 +1,106 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import {getAddon} from '../../../lib/pg/fetcher'
+import pgHost from '../../../lib/pg/host'
+import {legacyEssentialPlan, databaseNameFromUrl, essentialNumPlan, formatResponseWithCommands} from '../../../lib/pg/util'
+import {PgDatabase, PgUpgradeError, PgUpgradeResponse} from '../../../lib/pg/types'
+import * as Heroku from '@heroku-cli/schema'
+import confirmCommand from '../../../lib/confirmCommand'
+import {nls} from '../../../nls'
+
+export default class Upgrade extends Command {
+  static topic = 'pg';
+  static description = heredoc(`
+    starts a Postgres version upgrade
+
+    On Essential-tier databases, this command upgrades the database's Postgres version.
+
+    On Standard-tier and higher leader databases, this command runs a previously scheduled Postgres version upgrade. You must run ${color.cmd('pg:upgrade:prepare')} before this command to schedule a version upgrade.
+
+    On follower databases, this command unfollows the leader database before upgrading the follower's Postgres version.
+    `)
+
+  static examples = [
+    heredoc`
+      # Upgrade an Essential-tier database to a specific version
+      $ heroku pg:upgrade:run postgresql-curved-12345 --version 14 --app myapp
+    `,
+    heredoc`
+      # Upgrade a Standard-tier follower database to the latest supported version
+      $ heroku pg:upgrade:run HEROKU_POSTGRESQL_BLUE_URL --app myapp
+    `,
+    heredoc`
+      # Run a previously scheduled upgrade on a Standard-tier leader database
+      $ heroku pg:upgrade:run DATABASE_URL --app myapp
+    `,
+  ]
+
+  static flags = {
+    confirm: flags.string({char: 'c'}),
+    version: flags.string({char: 'v', description: 'Postgres version to upgrade to'}),
+    app: flags.app({required: true}),
+    remote: flags.remote({char: 'r'}),
+  }
+
+  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(Upgrade)
+    const {app, version, confirm} = flags
+    const {database} = args
+
+    const db = await getAddon(this.heroku, app, database)
+    if (legacyEssentialPlan(db))
+      ux.error(`You can only use ${color.cmd('pg:upgrade:*')} commands on Essential-* and higher plans.`)
+
+    const versionPhrase = version ? heredoc(`Postgres version ${version}`) : heredoc('the latest supported Postgres version')
+    const {body: replica} = await this.heroku.get<PgDatabase>(`/client/v11/databases/${db.id}`, {hostname: pgHost()})
+
+    if (essentialNumPlan(db)) {
+      await confirmCommand(app, confirm, heredoc(`
+        Destructive action
+        You're upgrading ${color.addon(db.name)} to ${versionPhrase}.
+
+        You can't undo this action.
+      `))
+    } else if (replica.following) {
+      const {body: configVars} = await this.heroku.get<Heroku.ConfigVars>(`/apps/${app}/config-vars`)
+      const origin = databaseNameFromUrl(replica.following, configVars)
+
+      await confirmCommand(app, confirm, heredoc(`
+        Destructive action
+        You're upgrading ${color.addon(db.name)} to ${versionPhrase}. The database will stop following ${origin} and become writable.
+
+        You can't undo this action.
+      `))
+    } else {
+      await confirmCommand(app, confirm, heredoc(`
+        Destructive action
+        You're upgrading the Postgres version on ${color.addon(db.name)}. This action also upgrades any followers on the database.
+
+        You can't undo this action.
+      `))
+    }
+
+    try {
+      const data = {version}
+      ux.action.start(`Starting upgrade on ${color.addon(db.name)}`)
+      const response = await this.heroku.post<PgUpgradeResponse>(`/client/v11/databases/${db.id}/upgrade/run`, {hostname: pgHost(), body: data})
+      ux.action.stop(heredoc(`done\n${formatResponseWithCommands(response.body.message)}`))
+    } catch (error) {
+      if (error instanceof Error && 'body' in error) {
+        const response = error as PgUpgradeError
+        ux.error(heredoc(`${formatResponseWithCommands(response.body.message)}\n\nError ID: ${response.body.id}`))
+      } else {
+        throw error
+      }
+    }
+  }
+}
+*/

package/lib/oldCommands/pg/upgrade/wait.d.ts

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

package/lib/oldCommands/pg/upgrade/wait.js

@@ -0,0 +1,121 @@
+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 heredoc from 'tsheredoc'
+import {getAddon} from '../../../lib/pg/fetcher'
+import pgHost from '../../../lib/pg/host'
+import notify from '../../../lib/notify'
+import {AddOnAttachmentWithConfigVarsAndPlan, AddOnWithRelatedData, PgUpgradeStatus} from '../../../lib/pg/types'
+import {HTTPError} from '@heroku/http-call'
+import {nls} from '../../../nls'
+import {formatResponseWithCommands} from '../../../lib/pg/util'
+
+const wait = (ms: number) => new Promise(resolve => {
+  setTimeout(resolve, ms)
+})
+
+export default class Wait extends Command {
+  static topic = 'pg'
+  static description = 'provides the status of an upgrade and blocks it until the operation is complete'
+  static flags = {
+    'wait-interval': flags.integer({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 examples = [
+    heredoc(`
+      # Wait for upgrade to complete with default settings
+      $ heroku pg:upgrade:wait postgresql-curved-12345 --app myapp
+    `),
+    heredoc(`
+      # Wait with custom polling interval
+      $ heroku pg:upgrade:wait postgresql-curved-12345 --app myapp --wait-interval 10
+    `),
+    heredoc(`
+      # Wait without showing OS notifications
+      $ heroku pg:upgrade:wait postgresql-curved-12345 --app myapp --no-notify
+    `),
+  ]
+
+  static args = {
+    database: Args.string({description: `${nls('pg:database:arg:description')}`}),
+  }
+
+  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) => {
+      const interval = (!waitInterval || waitInterval < 0) ? 5 : waitInterval
+      let status
+      let waiting = false
+      let retries = 20
+      const notFoundMessage = 'Waiting to provision...'
+
+      while (true) {
+        try {
+          ({body: status} = await this.heroku.get<PgUpgradeStatus>(
+            `/client/v11/databases/${db.id}/upgrade/wait_status`,
+            {hostname: pgHost()},
+          ))
+        } catch (error) {
+          if (error instanceof HTTPError && (!retries || error.statusCode !== 404)) {
+            const httpError = error as HTTPError
+            pgDebug(httpError)
+            throw httpError
+          }
+
+          retries--
+          status = {'waiting?': true, message: notFoundMessage}
+        }
+
+        let message = formatResponseWithCommands(status.message)
+        if (status.step)
+          message = heredoc(`(${status.step}) ${message}`)
+
+        if (status['error?']) {
+          notify('error', `${db.name} ${message}`, false)
+          ux.error(message || '', {exit: 1})
+        }
+
+        if (!status['waiting?']) {
+          if (waiting) {
+            ux.action.stop(message)
+          } else {
+            ux.log(heredoc(`Waiting for database ${color.yellow(db.name)}... ${message}`))
+          }
+
+          return
+        }
+
+        if (!waiting) {
+          waiting = true
+          ux.action.start(`Waiting for database ${color.yellow(db.name)}`, message)
+        }
+
+        ux.action.status = message
+
+        await wait(interval * 1000)
+      }
+    }
+
+    let dbs: AddOnAttachmentWithConfigVarsAndPlan[] | AddOnWithRelatedData[] | [] = []
+    if (dbName) {
+      dbs = [await getAddon(this.heroku, app, dbName)]
+    } else {
+      ux.error(heredoc('You must provide a database. Run `--help` for more information on the command.'))
+    }
+
+    for (const db of dbs) {
+      await waitFor(db)
+    }
+  }
+}
+*/

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

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

package/lib/oldCommands/pg/upgrade.js

@@ -0,0 +1,66 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import {getAddon} from '../../lib/pg/fetcher'
+import pgHost from '../../lib/pg/host'
+import {legacyEssentialPlan, databaseNameFromUrl} from '../../lib/pg/util'
+import {PgDatabase} from '../../lib/pg/types'
+import * as Heroku from '@heroku-cli/schema'
+import confirmCommand from '../../lib/confirmCommand'
+import {nls} from '../../nls'
+
+export default class Upgrade extends Command {
+  static topic = 'pg';
+  static description = heredoc(`
+    For an Essential-* plan, this command upgrades the database's PostgreSQL version. For a Standard-tier and higher plan, this command unfollows the leader database before upgrading the PostgreSQL version.
+    To upgrade to another PostgreSQL version, use pg:copy instead
+  `)
+
+  static flags = {
+    confirm: flags.string({char: 'c'}),
+    version: flags.string({char: 'v', description: 'PostgreSQL version to upgrade to'}),
+    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(Upgrade)
+    const {app, version, confirm} = flags
+    const {database} = args
+
+    const db = await getAddon(this.heroku, app, database)
+    if (legacyEssentialPlan(db))
+      ux.error('pg:upgrade is only available for Essential-* databases and follower databases on Standard-tier and higher plans.')
+    const {body: replica} = await this.heroku.get<PgDatabase>(`/client/v11/databases/${db.id}`, {hostname: pgHost()})
+    if (replica.following) {
+      const {body: configVars} = await this.heroku.get<Heroku.ConfigVars>(`/apps/${app}/config-vars`)
+      const origin = databaseNameFromUrl(replica.following, configVars)
+      await confirmCommand(app, confirm, heredoc(`
+        Destructive action
+        ${color.addon(db.name)} will be upgraded to a newer PostgreSQL version, stop following ${origin}, and become writable.
+
+        This cannot be undone.
+      `))
+    } else {
+      await confirmCommand(app, confirm, heredoc(`
+        Destructive action
+        ${color.addon(db.name)} will be upgraded to a newer PostgreSQL version.
+
+        This cannot be undone.
+      `))
+    }
+
+    const data = {version}
+    ux.action.start(`Starting upgrade of ${color.addon(db.name)}`)
+    await this.heroku.post(`/client/v11/databases/${db.id}/upgrade`, {hostname: pgHost(), body: data})
+    ux.action.stop(`Use ${color.cmd('heroku pg:wait')} to track status`)
+  }
+}
+*/

package/lib/oldCommands/pg/vacuum-stats.d.ts

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

package/lib/{commands → oldCommands}/pg/vacuum-stats.js

@@ -1,16 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("@heroku-cli/command");
-const core_1 = require("@oclif/core");
-const fetcher_1 = require("../../lib/pg/fetcher");
-const psql_1 = require("../../lib/pg/psql");
-const tsheredoc_1 = require("tsheredoc");
-const nls_1 = require("../../nls");
-class VacuumStats extends command_1.Command {
-    async run() {
-        const { flags, args } = await this.parse(VacuumStats);
-        const db = await (0, fetcher_1.database)(this.heroku, flags.app, args.database);
-        const query = (0, tsheredoc_1.default)(`
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {database} from '../../lib/pg/fetcher'
+import {exec} from '../../lib/pg/psql'
+import heredoc from 'tsheredoc'
+import {nls} from '../../nls'
+
+export default class VacuumStats extends Command {
+  static topic = 'pg';
+  static description = 'show dead rows and whether an automatic vacuum is expected to be triggered';
+  static flags = {
+    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(VacuumStats)
+    const db = await database(this.heroku, flags.app, args.database)
+    const query = heredoc(`
       WITH table_opts AS (
         SELECT
           pg_class.oid, relname, nspname, array_to_string(reloptions, '') AS relopts
@@ -49,18 +61,9 @@ class VacuumStats extends command_1.Command {
         pg_stat_user_tables psut INNER JOIN pg_class ON psut.relid = pg_class.oid
           INNER JOIN vacuum_settings ON pg_class.oid = vacuum_settings.oid
       ORDER BY 1
-    `);
-        const output = await (0, psql_1.exec)(db, query);
-        core_1.ux.log(output);
-    }
+    `)
+    const output = await exec(db, query)
+    ux.log(output)
+  }
 }
-exports.default = VacuumStats;
-VacuumStats.topic = 'pg';
-VacuumStats.description = 'show dead rows and whether an automatic vacuum is expected to be triggered';
-VacuumStats.flags = {
-    app: command_1.flags.app({ required: true }),
-    remote: command_1.flags.remote(),
-};
-VacuumStats.args = {
-    database: core_1.Args.string({ description: `${(0, nls_1.nls)('pg:database:arg:description')} ${(0, nls_1.nls)('pg:database:arg:description:default:suffix')}` }),
-};
+*/

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

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

package/lib/oldCommands/pg/wait.js

@@ -0,0 +1,96 @@
+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/add.d.ts

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

package/lib/oldCommands/pipelines/add.js

@@ -0,0 +1,70 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {StageCompletion} from '@heroku-cli/command/lib/completions'
+import {Args, ux} from '@oclif/core'
+import {prompt} from 'inquirer'
+
+import {createCoupling} from '../../lib/api'
+import disambiguate from '../../lib/pipelines/disambiguate'
+import infer from '../../lib/pipelines/infer'
+import {inferrableStageNames as stageNames} from '../../lib/pipelines/stages'
+
+export default class PipelinesAdd extends Command {
+  static description = `add this app to a pipeline
+The app and pipeline names must be specified.
+The stage of the app will be guessed based on its name if not specified.`
+
+  static examples = [
+    '$ heroku pipelines:add my-pipeline -a my-app -s production',
+  ]
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    stage: flags.string({
+      char: 's',
+      description: 'stage of first app in pipeline',
+      completion: StageCompletion,
+    }),
+  }
+
+  static args = {
+    pipeline: Args.string({
+      description: 'name of pipeline',
+      required: true,
+    }),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(PipelinesAdd)
+    const app = flags.app
+
+    let stage
+    const guesses = infer(app)
+    const questions = []
+
+    const pipeline: any = await disambiguate(this.heroku, args.pipeline)
+
+    if (flags.stage) {
+      stage = flags.stage
+    } else {
+      questions.push({
+        type: 'list',
+        name: 'stage',
+        message: `Stage of ${app}`,
+        choices: stageNames,
+        default: guesses[1],
+      })
+    }
+
+    const answers: any = await prompt(questions)
+    if (answers.stage) stage = answers.stage
+
+    ux.action.start(`Adding ${color.app(app)} to ${color.pipeline(pipeline.name)} pipeline as ${stage}`)
+    await createCoupling(this.heroku, pipeline, app, stage)
+    ux.action.stop()
+  }
+}
+*/

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

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

package/lib/oldCommands/pipelines/connect.js

@@ -0,0 +1,69 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+
+import {getPipeline} from '../../lib/api'
+import GitHubAPI from '../../lib/pipelines/github-api'
+import KolkrabbiAPI from '../../lib/pipelines/kolkrabbi-api'
+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 {nameAndRepo} from '../../lib/pipelines/setup/validate'
+
+export default class Connect extends Command {
+  static description = 'connect a GitHub repo to an existing pipeline'
+
+  static examples = [
+    '$ heroku pipelines:connect my-pipeline -r githuborg/reponame',
+  ]
+
+  static flags = {
+    repo: flags.string({
+      name: 'repo',
+      char: 'r',
+      description: 'the GitHub repository to connect to',
+      required: true,
+    }),
+  }
+
+  static args = {
+    name: Args.string({
+      description: 'name of pipeline',
+      required: true,
+    }),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(Connect)
+
+    const combinedInputs = {
+      name: args.name,
+      repo: flags.repo,
+    }
+
+    const errors = nameAndRepo({repo: flags.repo})
+
+    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 {
+      name: pipelineName,
+      repo: repoName,
+    } = await getNameAndRepo(combinedInputs)
+
+    const repo = await getRepo(github, repoName)
+
+    const pipeline = await getPipeline(this.heroku, pipelineName)
+
+    ux.action.start('Linking to repo')
+    await kolkrabbi.createPipelineRepository(pipeline.body.id, repo.id)
+    ux.action.stop()
+  }
+}
+*/

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

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