heroku 10.13.2 → 11.0.0-alpha.10

package/lib/oldCommands/pg/outliers.js

@@ -0,0 +1,110 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args, ux} from '@oclif/core'
+import {database} from '../../lib/pg/fetcher'
+import {exec, fetchVersion} from '../../lib/pg/psql'
+import {getConnectionDetails} from '../../lib/pg/util'
+import heredoc from 'tsheredoc'
+import {nls} from '../../nls'
+
+export default class Outliers extends Command {
+  static topic = 'pg'
+  static description = 'show 10 queries that have longest execution time in aggregate'
+  static flags = {
+    reset: flags.boolean({description: 'resets statistics gathered by pg_stat_statements'}),
+    truncate: flags.boolean({char: 't', description: 'truncate queries to 40 characters'}),
+    num: flags.string({char: 'n', description: 'the number of queries to display (default: 10)'}),
+    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(Outliers)
+    const {app, reset, truncate, num} = flags
+
+    const db = await database(this.heroku, app, args.database)
+    const version = await fetchVersion(db)
+    await this.ensurePGStatStatement(db)
+
+    if (reset) {
+      await exec(db, 'SELECT pg_stat_statements_reset();')
+      return
+    }
+
+    let limit = 10
+    if (num) {
+      if (/^(\d+)$/.exec(num)) {
+        limit = Number.parseInt(num, 10)
+      } else {
+        ux.error(`Cannot parse num param value "${num}" to a number`)
+      }
+    }
+
+    const query = this.outliersQuery(version, limit, truncate)
+    const output = await exec(db, query)
+    ux.log(output)
+  }
+
+  protected async ensurePGStatStatement(db: ReturnType<typeof getConnectionDetails>) {
+    const query = heredoc`
+      SELECT exists(
+        SELECT 1
+        FROM pg_extension e
+          LEFT JOIN pg_namespace n ON n.oid = e.extnamespace
+        WHERE e.extname = 'pg_stat_statements' AND n.nspname IN ('public', 'heroku_ext')
+      ) AS available;
+    `
+    const output = await exec(db, query)
+
+    if (!output.includes('t')) {
+      ux.error(heredoc`
+        pg_stat_statements extension need to be installed first.
+        You can install it by running: CREATE EXTENSION pg_stat_statements WITH SCHEMA heroku_ext;
+      `)
+    }
+  }
+
+  protected outliersQuery(version: string | undefined, limit: number, truncate: boolean) {
+    const truncatedQueryString = truncate ? heredoc`
+      CASE WHEN length(query) <= 40 THEN query ELSE substr(query, 0, 39) || '…' END
+    ` : 'query'
+
+    let totalExecTimeField = ''
+    if (version && Number.parseInt(version, 10) >= 13) {
+      totalExecTimeField = 'total_exec_time'
+    } else {
+      totalExecTimeField = 'total_time'
+    }
+
+    let blkReadTimeField = ''
+    let blkWriteTimeField = ''
+    if (version && Number.parseInt(version, 10) >= 17) {
+      blkReadTimeField = 'shared_blk_read_time'
+      blkWriteTimeField = 'shared_blk_write_time'
+    } else {
+      blkReadTimeField = 'blk_read_time'
+      blkWriteTimeField = 'blk_write_time'
+    }
+
+    return heredoc`
+        SELECT
+          interval '1 millisecond' * ${totalExecTimeField} AS total_exec_time,
+          to_char((${totalExecTimeField}/sum(${totalExecTimeField}) OVER()) * 100, 'FM90D0') || '%'  AS prop_exec_time,
+          to_char(calls, 'FM999G999G999G990') AS ncalls,
+          interval '1 millisecond' * (${blkReadTimeField} + ${blkWriteTimeField}) AS sync_io_time,
+          ${truncatedQueryString} AS query
+        FROM pg_stat_statements
+        WHERE userid = (
+          SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1
+        )
+        ORDER BY ${totalExecTimeField} DESC
+        LIMIT ${limit};
+      `
+  }
+}
+*/

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

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

package/lib/oldCommands/pg/promote.js

@@ -0,0 +1,183 @@
+export {};
+/* eslint-disable complexity */
+/*
+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 heredoc from 'tsheredoc'
+import {getAttachment, getRelease} from '../../lib/pg/fetcher'
+import pgHost from '../../lib/pg/host'
+import {PgStatus, PgDatabase} from '../../lib/pg/types'
+import {nls} from '../../nls'
+
+export default class Promote extends Command {
+  static topic = 'pg';
+  static description = 'sets DATABASE as your DATABASE_URL';
+  static flags = {
+    force: flags.boolean({char: 'f'}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    database: Args.string({required: true, description: nls('pg:database:arg:description')}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Promote)
+    const {force, app} = flags
+    const {database} = args
+    const attachment = await getAttachment(this.heroku, app, database)
+    ux.action.start(`Ensuring an alternate alias for existing ${color.green('DATABASE_URL')}`)
+    const {body: attachments} = await this.heroku.get<Heroku.AddOnAttachment[]>(`/apps/${app}/addon-attachments`)
+    const current = attachments.find(a => a.name === 'DATABASE')
+    if (current) {
+      // eslint-disable-next-line eqeqeq
+      if (current.addon?.name === attachment.addon.name && current.namespace == attachment.namespace) {
+        if (attachment.namespace) {
+          ux.error(`${color.cyan(attachment.name)} is already promoted on ${color.app(app)}`)
+        } else {
+          ux.error(`${color.addon(attachment.addon.name)} is already promoted on ${color.app(app)}`)
+        }
+      }
+
+      const existing = attachments.filter(a => a.addon?.id === current.addon?.id && a.namespace === current.namespace)
+        .find(a => a.name !== 'DATABASE')
+      if (existing) {
+        ux.action.stop(color.green(existing.name + '_URL'))
+      } else {
+        // The current add-on occupying the DATABASE attachment has no
+        // other attachments. In order to promote this database without
+        // error, we can create a secondary attachment, just-in-time.
+        const {body: backup} = await this.heroku.post<Heroku.AddOnAttachment>('/addon-attachments', {
+          body: {
+            app: {name: app},
+            addon: {name: current.addon?.name},
+            namespace: current.namespace,
+            confirm: app,
+          },
+        })
+        ux.action.stop(color.green(backup.name + '_URL'))
+      }
+    }
+
+    if (!force) {
+      const {body: status} = await this.heroku.get<PgStatus>(`/client/v11/databases/${attachment.addon.id}/wait_status`, {
+        hostname: pgHost(),
+      })
+      if (status['waiting?']) {
+        ux.error(heredoc(`
+          Database cannot be promoted while in state: ${status.message}
+
+          Promoting this database can lead to application errors and outage. Please run ${color.cmd('heroku pg:wait')} to wait for database to become available.
+
+          To ignore this error, you can pass the --force flag to promote the database and risk application issues.
+        `))
+      }
+    }
+
+    let promotionMessage
+    if (attachment.namespace) {
+      promotionMessage = `Promoting ${color.cyan(attachment.name)} to ${color.green('DATABASE_URL')} on ${color.app(app)}`
+    } else {
+      promotionMessage = `Promoting ${color.addon(attachment.addon.name)} to ${color.green('DATABASE_URL')} on ${color.app(app)}`
+    }
+
+    ux.action.start(promotionMessage)
+    await this.heroku.post('/addon-attachments', {
+      body: {
+        name: 'DATABASE',
+        app: {name: app},
+        addon: {name: attachment.addon.name},
+        namespace: attachment.namespace || null,
+        confirm: app,
+      },
+    })
+    ux.action.stop()
+    const currentPooler = attachments.find(a => a.namespace === 'connection-pooling:default' && a.addon?.id === current?.addon?.id && a.name === 'DATABASE_CONNECTION_POOL')
+    if (currentPooler) {
+      ux.action.start('Reattaching pooler to new leader')
+      await this.heroku.post('/addon-attachments', {
+        body: {
+          name: currentPooler.name,
+          app: {name: app},
+          addon: {name: attachment.addon.name},
+          namespace: 'connection-pooling:default',
+          confirm: app,
+        },
+      })
+      ux.action.stop()
+    }
+
+    const {body: promotedDatabaseDetails} = await this.heroku.get<PgDatabase>(`/client/v11/databases/${attachment.addon.id}`, {
+      hostname: pgHost(),
+    })
+    if (promotedDatabaseDetails.following) {
+      const unfollowLeaderCmd = `heroku pg:unfollow ${attachment.addon.name}`
+      ux.warn(heredoc(`
+        Your database has been promoted but it is currently a follower database in read-only mode.
+
+        Promoting a database with ${color.cmd('heroku pg:promote')} doesn't automatically unfollow its leader.
+
+        Use ${color.cmd(unfollowLeaderCmd)} to stop this follower from replicating from its leader (${color.yellow(promotedDatabaseDetails.leader as string)}) and convert it into a writable database.
+      `))
+    }
+
+    const {body: formation} = await this.heroku.get<Heroku.Formation[]>(`/apps/${app}/formation`)
+    const releasePhase = formation.find(process => process.type === 'release')
+    if (releasePhase) {
+      ux.action.start('Checking release phase')
+      const {body: releases} = await this.heroku.get<Heroku.Release[]>(`/apps/${app}/releases`, {
+        partial: true,
+        headers: {
+          Range: 'version ..; max=5, order=desc',
+        },
+      })
+
+      const attach = releases.find(release => release.description?.includes('Attach DATABASE'))
+      const detach = releases.find(release => release.description?.includes('Detach DATABASE'))
+      if (!attach || !detach) {
+        ux.error('Unable to check release phase. Check your Attach DATABASE release for failures.')
+      }
+
+      const endTime = Date.now() + 900000 // 15 minutes from now
+      const [attachId, detachId] = [attach?.id as string, detach?.id as string]
+      while (true) {
+        const attach = await getRelease(this.heroku, app, attachId)
+        if (attach && attach.status === 'succeeded') {
+          let msg = 'pg:promote succeeded.'
+          const detach = await getRelease(this.heroku, app, detachId)
+          if (detach && detach.status === 'failed') {
+            msg += ` It is safe to ignore the failed ${detach.description} release.`
+          }
+
+          ux.action.stop(msg)
+          return
+        }
+
+        if (attach && attach.status === 'failed') {
+          let msg = `pg:promote failed because ${attach.description} release was unsuccessful. Your application is currently running `
+          const detach = await getRelease(this.heroku, app, detachId)
+          if (detach && detach.status === 'succeeded') {
+            msg += 'without an attached DATABASE_URL.'
+          } else {
+            msg += `with ${current?.addon?.name} attached as DATABASE_URL.`
+          }
+
+          msg += ' Check your release phase logs for failure causes.'
+          ux.action.stop(msg)
+          return
+        }
+
+        if (Date.now() > endTime) {
+          ux.action.stop('timeout. Check your Attach DATABASE release for failures.')
+          return
+        }
+
+        await new Promise(resolve => setTimeout(resolve, 5000))
+      }
+    }
+  }
+}
+*/

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

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

package/lib/oldCommands/pg/ps.js

@@ -0,0 +1,56 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {Args} 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 Ps extends Command {
+  static topic = 'pg'
+  static description = 'view active queries with execution time'
+  static flags = {
+    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(Ps)
+    const {database: databaseName} = args
+    const {verbose, app} = flags
+    const db = await database(this.heroku, app, databaseName)
+    const num = Math.random()
+    const waitingMarker = `${num}${num}`
+    const waitingQuery = heredoc(`
+    SELECT '${num}' || '${num}'
+    WHERE EXISTS
+        (SELECT 1
+         FROM information_schema.columns
+         WHERE table_schema = 'pg_catalog'
+           AND TABLE_NAME = 'pg_stat_activity'
+           AND COLUMN_NAME = 'waiting')
+    `)
+    const waitingOutput = await exec(db, waitingQuery)
+    const waiting = waitingOutput.includes(waitingMarker) ? 'waiting' : 'wait_event IS NOT NULL AS waiting'
+    const query = heredoc(`SELECT pid,
+           state,
+           application_name AS SOURCE,
+           usename AS username,
+           age(now(), xact_start) AS running_for,
+           xact_start AS transaction_start, ${waiting}, query
+    FROM pg_stat_activity
+    WHERE query <> '<insufficient privilege>' ${verbose ? '' : "AND state <> 'idle'"}
+      AND pid <> pg_backend_pid()
+    ORDER BY query_start DESC
+    `)
+    const output = await exec(db, query)
+    process.stdout.write(output)
+  }
+}
+*/

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

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

package/lib/oldCommands/pg/psql.js

@@ -0,0 +1,53 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import {database} from '../../lib/pg/fetcher'
+import {exec, execFile, interactive} from '../../lib/pg/psql'
+import {nls} from '../../nls'
+
+export default class Psql extends Command {
+    static description = 'open a psql shell to the database';
+    static flags = {
+      command: flags.string({char: 'c', description: 'SQL command to run'}),
+      file: flags.string({char: 'f', description: 'SQL file to run'}),
+      credential: flags.string({description: 'credential to use'}),
+      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')}`}),
+    };
+
+    static aliases = ['psql']
+
+    public async run(): Promise<void> {
+      const {flags, args} = await this.parse(Psql)
+      const {app, command, credential, file} = flags
+      const namespace = credential ? `credential:${credential}` : undefined
+      let db
+      try {
+        db = await database(this.heroku, app, args.database, namespace)
+      } catch (error) {
+        if (namespace && error instanceof Error && error.message === "Couldn't find that addon.") {
+          throw new Error("Credential doesn't match, make sure credential is attached")
+        }
+
+        throw error
+      }
+
+      console.error(`--> Connecting to ${color.yellow(db.attachment.addon.name)}`)
+      if (command) {
+        const output = await exec(db, command)
+        process.stdout.write(output)
+      } else if (file) {
+        const output = await execFile(db, file)
+        process.stdout.write(output)
+      } else {
+        await interactive(db)
+      }
+    }
+}
+*/

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

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

package/lib/oldCommands/pg/pull.js

@@ -0,0 +1,114 @@
+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 {database} from '../../lib/pg/fetcher'
+import {ConnectionDetails, parsePostgresConnectionString} from '../../lib/pg/util'
+import {
+  connArgs,
+  maybeTunnel,
+  parseExclusions,
+  prepare,
+  spawnPipe,
+  verifyExtensionsMatch,
+} from '../../lib/pg/push_pull'
+import {SpawnOptions, spawn} from 'node:child_process'
+import {nls} from '../../nls'
+const env = process.env
+
+export default class Pull extends Command {
+  static topic = 'pg'
+  static description = heredoc`
+    pull Heroku database into local or remote database
+    Pull from SOURCE into TARGET.
+
+    TARGET must be one of:
+    * a database name (i.e. on a local PostgreSQL server)  => TARGET must not exist and will be created
+    * a fully qualified URL to a local PostgreSQL server   => TARGET must not exist and will be created
+    * a fully qualified URL to a remote PostgreSQL server  => TARGET must exist and be empty
+
+    To delete a local database run ${color.cmd('dropdb TARGET')}.
+    To create an empty remote database, run ${color.cmd('createdb')} with connection command-line options (run ${color.cmd('createdb --help')} for details).
+  `
+
+  static examples = [heredoc`
+    # pull Heroku DB named postgresql-swimmingly-100 into local DB mylocaldb that must not exist
+    $ heroku pg:pull postgresql-swimmingly-100 mylocaldb --app sushi
+  `, heredoc`
+    # pull Heroku DB named postgresql-swimmingly-100 into empty remote DB at postgres://myhost/mydb
+    $ heroku pg:pull postgresql-swimmingly-100 postgres://myhost/mydb --app sushi
+  `]
+
+  static flags = {
+    'exclude-table-data': flags.string({description: 'tables for which data should be excluded (use \';\' to split multiple names)', hasValue: true}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    source: Args.string({required: true, description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+    target: Args.string({required: true, description: 'PostgreSQL connection string for the target database'}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Pull)
+    const {app, 'exclude-table-data': excludeTableData} = flags
+
+    const exclusions = parseExclusions(excludeTableData)
+    const source = await database(this.heroku, app, args.source)
+    const target = parsePostgresConnectionString(args.target)
+
+    ux.log(`Pulling ${color.cyan(source.attachment.addon.name)} to ${color.addon(args.target)}`)
+    await this.pull(source, target, exclusions)
+    ux.log('Pulling complete.')
+  }
+
+  protected async pull(
+    sourceIn: ConnectionDetails,
+    targetIn: ConnectionDetails,
+    exclusions: string[]) {
+    await prepare(targetIn)
+
+    const source = await maybeTunnel(sourceIn)
+    const target = await maybeTunnel(targetIn)
+    const exclude = exclusions.map(function (e) {
+      return '--exclude-table-data=' + e
+    }).join(' ')
+
+    const dumpFlags = ['--verbose', '-F', 'c', '-Z', '0', '-N', '_heroku', ...connArgs(source, true)]
+
+    if (exclude !== '') dumpFlags.push(exclude)
+
+    const dumpOptions: SpawnOptions & {env: NodeJS.ProcessEnv} = {
+      env: {
+        PGSSLMODE: 'prefer',
+        ...env,
+      } as {[key: string]: string},
+      stdio: ['pipe', 'pipe', 2],
+      shell: true,
+    }
+    if (source.password) dumpOptions.env.PGPASSWORD = source.password
+
+    const restoreFlags = ['--verbose', '-F', 'c', '--no-acl', '--no-owner', ...connArgs(target)]
+
+    const restoreOptions: SpawnOptions & {env: NodeJS.ProcessEnv} = {
+      env: {...env},
+      stdio: ['pipe', 'pipe', 2],
+      shell: true,
+    }
+    if (target.password) restoreOptions.env.PGPASSWORD = target.password
+
+    const pgDump = spawn('pg_dump', dumpFlags, dumpOptions)
+    const pgRestore = spawn('pg_restore', restoreFlags, restoreOptions)
+
+    await spawnPipe(pgDump, pgRestore)
+
+    if (source._tunnel) source._tunnel.close()
+    if (target._tunnel) target._tunnel.close()
+
+    await verifyExtensionsMatch(sourceIn, targetIn)
+  }
+}
+*/

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

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

package/lib/oldCommands/pg/push.js

@@ -0,0 +1,111 @@
+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 {database} from '../../lib/pg/fetcher'
+import {ConnectionDetails, parsePostgresConnectionString} from '../../lib/pg/util'
+import {
+  connArgs,
+  maybeTunnel,
+  parseExclusions,
+  prepare,
+  spawnPipe,
+  verifyExtensionsMatch,
+} from '../../lib/pg/push_pull'
+import {SpawnOptions, spawn} from 'node:child_process'
+import {nls} from '../../nls'
+const env = process.env
+
+export default class Push extends Command {
+  static topic = 'pg'
+  static description = heredoc`
+    push local or remote into Heroku database
+    Push from SOURCE into TARGET. TARGET must be empty.
+
+    To empty a Heroku database for push run ${color.cmd('heroku pg:reset')}
+
+    SOURCE must be either the name of a database existing on your localhost or the
+    fully qualified URL of a remote database.
+  `
+
+  static examples = [heredoc`
+      # push mylocaldb into a Heroku DB named postgresql-swimmingly-100
+      $ heroku pg:push mylocaldb postgresql-swimmingly-100 --app sushi
+    `, heredoc`
+      # push remote DB at postgres://myhost/mydb into a Heroku DB named postgresql-swimmingly-100
+      $ heroku pg:push postgres://myhost/mydb postgresql-swimmingly-100 --app sushi
+  `]
+
+  static flags = {
+    'exclude-table-data': flags.string({description: 'tables for which data should be excluded (use \';\' to split multiple names)', hasValue: true}),
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  static args = {
+    source: Args.string({required: true, description: 'PostgreSQL connection string for the source database'}),
+    target: Args.string({required: true, description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, args} = await this.parse(Push)
+    const {app, 'exclude-table-data': excludeTableData} = flags
+
+    const exclusions = parseExclusions(excludeTableData)
+    const source = parsePostgresConnectionString(args.source)
+    const target = await database(this.heroku, app, args.target)
+
+    ux.log(`Pushing ${color.cyan(args.source)} to ${color.addon(target.attachment.addon.name)}`)
+    await this.push(source, target, exclusions)
+    ux.log('Pushing complete.')
+  }
+
+  protected async push(
+    sourceIn: ConnectionDetails,
+    targetIn: ConnectionDetails,
+    exclusions: string[]) {
+    await prepare(targetIn)
+
+    const source = await maybeTunnel(sourceIn)
+    const target = await maybeTunnel(targetIn)
+    const exclude = exclusions.map(function (e) {
+      return '--exclude-table-data=' + e
+    }).join(' ')
+
+    const dumpFlags = ['--verbose', '-F', 'c', '-Z', '0', '-N', '_heroku', ...connArgs(source, true)]
+
+    if (exclude !== '') dumpFlags.push(exclude)
+
+    const dumpOptions: SpawnOptions & {env: NodeJS.ProcessEnv} = {
+      env: {
+        PGSSLMODE: 'prefer',
+        ...env,
+      } as {[key: string]: string},
+      stdio: ['pipe', 'pipe', 2],
+      shell: true,
+    }
+    if (source.password) dumpOptions.env.PGPASSWORD = source.password
+
+    const restoreFlags = ['--verbose', '-F', 'c', '--no-acl', '--no-owner', ...connArgs(target)]
+
+    const restoreOptions: SpawnOptions & {env: NodeJS.ProcessEnv} = {
+      env: {...env},
+      stdio: ['pipe', 'pipe', 2],
+      shell: true,
+    }
+    if (target.password) restoreOptions.env.PGPASSWORD = target.password
+
+    const pgDump = spawn('pg_dump', dumpFlags, dumpOptions)
+    const pgRestore = spawn('pg_restore', restoreFlags, restoreOptions)
+
+    await spawnPipe(pgDump, pgRestore)
+
+    if (source._tunnel) source._tunnel.close()
+    if (target._tunnel) target._tunnel.close()
+
+    await verifyExtensionsMatch(sourceIn, targetIn)
+  }
+}
+*/

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

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