heroku 10.13.2 → 11.0.0-alpha.10

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

@@ -0,0 +1,150 @@
+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 confirmCommand from '../../../lib/confirmCommand'
+import backupsFactory from '../../../lib/pg/backups'
+import {getAttachment} from '../../../lib/pg/fetcher'
+import host from '../../../lib/pg/host'
+import type {BackupTransfer} from '../../../lib/pg/types'
+import {nls} from '../../../nls'
+
+function dropboxURL(url: string) {
+  if (url.match(/^https?:\/\/www\.dropbox\.com/) && !url.endsWith('dl=1')) {
+    if (url.endsWith('dl=0'))
+      url = url.replace('dl=0', 'dl=1')
+    else if (url.includes('?'))
+      url += '&dl=1'
+    else
+      url += '?dl=1'
+  }
+
+  return url
+}
+
+export default class Restore extends Command {
+  static topic = 'pg'
+  static description = 'restore a backup (default latest) to a database'
+  static flags = {
+    'wait-interval': flags.integer({default: 3}),
+    extensions: flags.string({
+      char: 'e',
+      description: heredoc(`
+        comma-separated list of extensions to pre-install in the default
+        public schema or an optional custom schema
+        (for example: hstore or myschema.hstore)
+      `),
+    }),
+    verbose: flags.boolean({char: 'v'}),
+    confirm: flags.string({char: 'c'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    backup: Args.string({description: 'URL or backup ID from another app'}),
+    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+  }
+
+  static examples = [
+    heredoc(`
+    # Basic Restore from Backup ID
+    $ heroku pg:backups:restore b101 DATABASE_URL --app my-heroku-app
+    `),
+    heredoc(`
+    # Restore from Another App
+    $ heroku pg:backups:restore example-app::b101 DATABASE_URL --app my-heroku-app
+    `),
+    heredoc(`
+    # Restore from a Public URL
+    $ heroku pg:backups:restore 'https://s3.amazonaws.com/my-bucket/mydb.dump' DATABASE_URL --app my-heroku-app
+    `),
+    heredoc(`
+    # Verbose Output
+    $ heroku pg:backups:restore b101 DATABASE_URL --app my-heroku-app --verbose
+    `),
+    heredoc(`
+    # Restore with Confirmation Prompt
+    $ heroku pg:backups:restore b101 DATABASE_URL --app my-heroku-app --confirm my-heroku-app
+    `),
+    heredoc(`
+    # Restore with a Specific Database Name
+    $ heroku pg:backups:restore b101 HEROKU_POSTGRESQL_PINK --app my-heroku-app
+    `),
+  ]
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Restore)
+    const {app, 'wait-interval': waitInterval, extensions, confirm, verbose} = flags
+    const interval = Math.max(3, waitInterval)
+    const {addon: db} = await getAttachment(this.heroku, app as string, args.database)
+    const {name, wait} = backupsFactory(app, this.heroku)
+    let backupURL
+    let backupName = args.backup
+
+    if (backupName && backupName.match(/^https?:\/\//)) {
+      backupURL = dropboxURL(backupName)
+    } else {
+      let backupApp
+      if (backupName && backupName.match(/::/)) {
+        [backupApp, backupName] = backupName.split('::')
+      } else {
+        backupApp = app
+      }
+
+      const {body: transfers} = await this.heroku.get<BackupTransfer[]>(`/client/v11/apps/${backupApp}/transfers`, {hostname: host()})
+      const backups = transfers.filter(t => t.from_type === 'pg_dump' && t.to_type === 'gof3r')
+
+      let backup
+      if (backupName) {
+        backup = backups.find(b => name(b) === backupName)
+        if (!backup)
+          throw new Error(`Backup ${color.cyan(backupName)} not found for ${color.app(backupApp)}`)
+        if (!backup.succeeded)
+          throw new Error(`Backup ${color.cyan(backupName)} for ${color.app(backupApp)} did not complete successfully`)
+      } else {
+        backup = backups.filter(b => b.succeeded).sort((a, b) => {
+          if (a.finished_at < b.finished_at) {
+            return -1
+          }
+
+          if (a.finished_at > b.finished_at) {
+            return 1
+          }
+
+          return 0
+        }).pop()
+        if (!backup) {
+          throw new Error(`No backups for ${color.app(backupApp)}. Capture one with ${color.cyan.bold('heroku pg:backups:capture')}`)
+        }
+
+        backupName = name(backup)
+      }
+
+      backupURL = backup.to_url
+    }
+
+    await confirmCommand(app, confirm)
+    ux.action.start(`Starting restore of ${color.cyan(backupName)} to ${color.yellow(db.name)}`)
+    ux.log(heredoc(`
+
+    Use Ctrl-C at any time to stop monitoring progress; the backup will continue restoring.
+    Use ${color.cyan.bold('heroku pg:backups')} to check progress.
+    Stop a running restore with ${color.cyan.bold('heroku pg:backups:cancel')}.
+    `))
+
+    const {body: restore} = await this.heroku.post<{uuid: string}>(`/client/v11/databases/${db.id}/restores`, {
+      body: {backup_url: backupURL, extensions: this.getSortedExtensions(extensions as string)}, hostname: host(),
+    })
+
+    ux.action.stop()
+    await wait('Restoring', restore.uuid, interval, verbose, db.app.id as string)
+  }
+
+  protected getSortedExtensions(extensions: string | null | undefined): string[] | undefined {
+    return extensions?.split(',').map(ext => ext.trim().toLowerCase()).sort()
+  }
+}
+*/

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

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

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

@@ -0,0 +1,107 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import pgHost from '../../../lib/pg/host'
+import {getAttachment} from '../../../lib/pg/fetcher'
+import {PgDatabase} from '../../../lib/pg/types'
+import {HTTPError} from '@heroku/http-call'
+import {nls} from '../../../nls'
+
+type Timezone = {
+  PST: string
+  PDT: string
+  MST: string
+  MDT: string
+  CST: string
+  CDT: string
+  EST: string
+  EDT: string
+  Z: string
+  GMT: string
+  BST: string
+  CET: string
+  CEST: string
+}
+
+const TZ: Timezone = {
+  PST: 'America/Los_Angeles',
+  PDT: 'America/Los_Angeles',
+  MST: 'America/Boise',
+  MDT: 'America/Boise',
+  CST: 'America/Chicago',
+  CDT: 'America/Chicago',
+  EST: 'America/New_York',
+  EDT: 'America/New_York',
+  Z: 'UTC',
+  GMT: 'Europe/London',
+  BST: 'Europe/London',
+  CET: 'Europe/Paris',
+  CEST: 'Europe/Paris',
+}
+
+type BackupSchedule = {
+  hour: string
+  timezone: string
+  schedule_name?: string
+}
+
+export default class Schedule extends Command {
+  static topic = 'pg'
+  static description = 'schedule daily backups for given database'
+  static flags = {
+    at: flags.string({required: true, description: "at a specific (24h) hour in the given timezone. Defaults to UTC. --at '[HOUR]:00 [TIMEZONE]'"}),
+    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')}`}),
+  }
+
+  parseDate = function (at: string): BackupSchedule {
+    const m = at.match(/^(0?\d|1\d|2[0-3]):00 ?(\S*)$/)
+
+    if (m) {
+      const [, hour, timezone] = m
+      return {hour, timezone: TZ[timezone.toUpperCase() as keyof Timezone] || timezone || 'UTC'}
+    }
+
+    return ux.error("Invalid schedule format: expected --at '[HOUR]:00 [TIMEZONE]'", {exit: 1})
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Schedule)
+    const {app} = flags
+    const {database} = args
+
+    const schedule = this.parseDate(flags.at)
+    const attachment = await getAttachment(this.heroku, app, database)
+    const db = attachment.addon
+    const at = color.cyan(`${schedule.hour}:00 ${schedule.timezone}`)
+
+    const pgResponse = await this.heroku.get<PgDatabase>(`/client/v11/databases/${db.id}`, {hostname: pgHost()})
+      .catch((error: HTTPError) => {
+        if (error.statusCode !== 404)
+          throw error
+        ux.error(`${color.yellow(db.name)} is not yet provisioned.\nRun ${color.cyan.bold('heroku addons:wait')} to wait until the db is provisioned.`, {exit: 1})
+      })
+    const {body: dbInfo} = pgResponse || {body: null}
+    if (dbInfo) {
+      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.')
+      }
+    }
+
+    ux.action.start(`Scheduling automatic daily backups of ${color.yellow(db.name)} at ${at}`)
+    schedule.schedule_name = attachment.name + '_URL'
+    await this.heroku.post(`/client/v11/databases/${db.id}/transfer-schedules`, {
+      body: schedule, hostname: pgHost(),
+    })
+    ux.action.stop()
+  }
+}
+*/

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

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

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

@@ -0,0 +1,34 @@
+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 pgHost from '../../../lib/pg/host'
+import {arbitraryAppDB} from '../../../lib/pg/fetcher'
+import type {TransferSchedule} from '../../../lib/pg/types'
+
+export default class Schedules extends Command {
+  static topic = 'pg';
+  static description = 'list backup schedule';
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  };
+
+  public async run(): Promise<void> {
+    const {flags} = await this.parse(Schedules)
+    const {app} = flags
+    const db = await arbitraryAppDB(this.heroku, app)
+    const {body: schedules} = await this.heroku.get<TransferSchedule[]>(`/client/v11/databases/${db.id}/transfer-schedules`, {hostname: pgHost()})
+    if (schedules.length === 0) {
+      ux.warn(`No backup schedules found on ${color.app(app)}\nUse ${color.cyan.bold('heroku pg:backups:schedule')} to set one up`)
+    } else {
+      hux.styledHeader('Backup Schedules')
+      for (const s of schedules) {
+        ux.log(`${color.green(s.name)}: daily at ${s.hour}:00 ${s.timezone}`)
+      }
+    }
+  }
+}
+*/

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

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

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

@@ -0,0 +1,60 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {arbitraryAppDB, getAddon} from '../../../lib/pg/fetcher'
+import {TransferSchedule} from '../../../lib/pg/types'
+import pgHost from '../../../lib/pg/host'
+import {nls} from '../../../nls'
+
+export default class Unschedule extends Command {
+  static topic = 'pg';
+  static description = 'stop daily backups';
+  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:arbitrary:suffix')}`}),
+  };
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Unschedule)
+    const {app} = flags
+    const {database} = args
+    let db = database
+    if (!db) {
+      const appDB = await arbitraryAppDB(this.heroku, app)
+      const {body: schedules} = await this.heroku.get<TransferSchedule[]>(
+        `/client/v11/databases/${appDB.id}/transfer-schedules`,
+        {hostname: pgHost()},
+      )
+      if (schedules.length === 0)
+        throw new Error(`No schedules on ${color.app(app)}`)
+      if (schedules.length > 1) {
+        throw new Error(`Specify schedule on ${color.app(app)}. Existing schedules: ${schedules.map(s => color.green(s.name))
+          .join(', ')}`)
+      }
+
+      db = schedules[0].name
+    }
+
+    ux.action.start(`Unscheduling ${color.green(db)} daily backups`)
+    const addon = await getAddon(this.heroku, app, db)
+    const {body: schedules} = await this.heroku.get<TransferSchedule[]>(
+      `/client/v11/databases/${addon.id}/transfer-schedules`,
+      {hostname: pgHost()},
+    )
+    const schedule = schedules.find(s => s.name.match(new RegExp(`${db}`, 'i')))
+    if (!schedule)
+      throw new Error(`No daily backups found for ${color.yellow(addon.name)}`)
+    await this.heroku.delete(
+      `/client/v11/databases/${addon.id}/transfer-schedules/${schedule.uuid}`,
+      {hostname: pgHost()},
+    )
+    ux.action.stop()
+  }
+}
+*/

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

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

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

@@ -0,0 +1,46 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import host from '../../../lib/pg/host'
+import pgBackupsApi from '../../../lib/pg/backups'
+import {sortBy} from 'lodash'
+import type {BackupTransfer, PublicUrlResponse} from '../../../lib/pg/types'
+
+export default class Url extends Command {
+    static topic = 'pg';
+    static description = 'get secret but publicly accessible URL of a backup';
+    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 backup ID.'}),
+    };
+
+    public async run(): Promise<void> {
+      const {flags, args} = await this.parse(Url)
+      const {backup_id} = args
+      const {app} = flags
+
+      let num
+      if (backup_id) {
+        num = await pgBackupsApi(app, this.heroku).num(backup_id)
+        if (!num)
+          throw new Error(`Invalid Backup: ${backup_id}`)
+      } else {
+        const {body: transfers} = await this.heroku.get<BackupTransfer[]>(`/client/v11/apps/${app}/transfers`, {hostname: host()})
+        const lastBackup = sortBy(transfers.filter(t => t.succeeded && t.to_type === 'gof3r'), 'created_at')
+          .pop()
+        if (!lastBackup)
+          throw new Error(`No backups on ${color.app(app)}. Capture one with ${color.cyan.bold('heroku pg:backups:capture')}`)
+        num = lastBackup.num
+      }
+
+      const {body: info} = await this.heroku.post<PublicUrlResponse>(`/client/v11/apps/${app}/transfers/${num}/actions/public-url`, {hostname: host()})
+      ux.log(info.url)
+    }
+}
+*/

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

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

package/lib/{commands → oldCommands}/pg/bloat.js

@@ -1,10 +1,11 @@
-"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 nls_1 = require("../../nls");
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import {database} from '../../lib/pg/fetcher'
+import {exec} from '../../lib/pg/psql'
+import {nls} from '../../nls'
+
 const query = `
 WITH constants AS (
   SELECT current_setting('block_size')::numeric AS bs, 23 AS hdr, 4 AS ma
@@ -66,23 +67,27 @@ SELECT
 FROM
   index_bloat) bloat_summary
 ORDER BY raw_waste DESC, bloat DESC
-`;
-class Bloat extends command_1.Command {
-    async run() {
-        const { flags, args } = await this.parse(Bloat);
-        const { app } = flags;
-        const db = await (0, fetcher_1.database)(this.heroku, app, args.database);
-        const output = await (0, psql_1.exec)(db, query);
-        process.stdout.write(output);
-    }
+`
+
+export default class Bloat extends Command {
+  static topic = 'pg';
+  static description = 'show table and index bloat in your database ordered by most wasteful';
+  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(Bloat)
+    const {app} = flags
+    const db = await database(this.heroku, app, args.database)
+    const output = await exec(db, query)
+    process.stdout.write(output)
+  }
 }
-exports.default = Bloat;
-Bloat.topic = 'pg';
-Bloat.description = 'show table and index bloat in your database ordered by most wasteful';
-Bloat.flags = {
-    app: command_1.flags.app({ required: true }),
-    remote: command_1.flags.remote(),
-};
-Bloat.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/blocking.d.ts

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

package/lib/oldCommands/pg/blocking.js

@@ -0,0 +1,48 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import heredoc from 'tsheredoc'
+import {database} from '../../lib/pg/fetcher'
+import {exec} from '../../lib/pg/psql'
+import {nls} from '../../nls'
+
+export default class Blocking extends Command {
+    static topic = 'pg'
+    static description = 'display queries holding locks other queries are waiting to be released'
+    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(Blocking)
+      const {app} = flags
+      const query = heredoc`
+        SELECT bl.pid AS blocked_pid,
+          ka.query AS blocking_statement,
+          now() - ka.query_start AS blocking_duration,
+          kl.pid AS blocking_pid,
+          a.query AS blocked_statement,
+          now() - a.query_start AS blocked_duration
+        FROM pg_catalog.pg_locks bl
+        JOIN pg_catalog.pg_stat_activity a
+          ON bl.pid = a.pid
+        JOIN pg_catalog.pg_locks kl
+          JOIN pg_catalog.pg_stat_activity ka
+            ON kl.pid = ka.pid
+        ON bl.transactionid = kl.transactionid AND bl.pid != kl.pid
+        WHERE NOT bl.granted
+      `
+
+      const db = await database(this.heroku, app, args.database)
+      const output = await exec(db, query)
+
+      ux.log(output)
+    }
+}
+*/

package/lib/oldCommands/pg/connection-pooling/attach.d.ts

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

package/lib/oldCommands/pg/connection-pooling/attach.js

@@ -0,0 +1,53 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+import pghost from '../../../lib/pg/host'
+import heredoc from 'tsheredoc'
+import {essentialPlan} from '../../../lib/pg/util'
+import {getAddon} from '../../../lib/pg/fetcher'
+import {nls} from '../../../nls'
+
+export default class Attach extends Command {
+    static topic = 'pg'
+    static description = 'add an attachment to a database using connection pooling'
+    static examples = [heredoc`
+      $ heroku pg:connection-pooling:attach postgresql-something-12345
+    `]
+
+    static flags = {
+      as: flags.string({description: 'name for add-on attachment'}),
+      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(Attach)
+      const {app} = flags
+      const db = await getAddon(this.heroku, app, args.database)
+      const {body: addon} = await this.heroku.get<Required<Heroku.AddOn>>(`/addons/${encodeURIComponent(db.name)}`)
+
+      if (essentialPlan(db))
+        ux.error('You can’t perform this operation on Essential-tier databases.')
+
+      ux.action.start(`Enabling Connection Pooling on ${color.yellow(addon.name)} to ${color.magenta(app)}`)
+      const {body: attachment} = await this.heroku.post<Required<Heroku.AddOnAttachment>>(`/client/v11/databases/${encodeURIComponent(db.name)}/connection-pooling`, {
+        body: {name: flags.as, credential: 'default', app: app}, hostname: pghost(),
+      })
+      ux.action.stop()
+
+      ux.action.start(`Setting ${color.cyan(attachment.name)} config vars and restarting ${color.magenta(app)}`)
+      const {body: releases} = await this.heroku.get<Required<Heroku.Release>[]>(
+        `/apps/${app}/releases`,
+        {partial: true, headers: {Range: 'version ..; max=1, order=desc'}},
+      )
+      ux.action.stop(`done, v${releases[0].version}`)
+    }
+}
+*/

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

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