heroku 10.13.2 → 11.0.0-alpha.2

package/lib/oldCommands/pipelines/create.js

@@ -0,0 +1,105 @@
+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, type Answers, type InputQuestion, type ListQuestion} from 'inquirer'
+
+import {createCoupling, createPipeline, getAccountInfo, getTeam, Owner} from '../../lib/api'
+import infer from '../../lib/pipelines/infer'
+import {inferrableStageNames as stages} from '../../lib/pipelines/stages'
+import {getGenerationByAppId} from '../../lib/apps/generation'
+
+export default class Create extends Command {
+  static description = `create a new pipeline
+  An existing app must be specified as the first app in the pipeline.
+  The pipeline name will be inferred from the app name if not specified.
+  The stage of the app will be guessed based on its name if not specified.
+  The pipeline owner will be the user creating the pipeline if not specified with -t for teams or -o for orgs.`
+
+  static examples = [
+    '$ heroku pipelines:create -a my-app-staging',
+    '$ heroku pipelines:create my-pipeline -a my-app-staging',
+  ]
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    stage: flags.string({
+      name: 'stage',
+      char: 's',
+      description: 'stage of first app in pipeline',
+      completion: StageCompletion,
+    }),
+    team: flags.team({
+      description: 'the team which will own the apps',
+    }),
+  }
+
+  static args = {
+    name: Args.string({
+      description: 'name of pipeline (defaults to basename of the app)',
+      required: false,
+    }),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(Create)
+
+    let name
+    let stage
+    let owner: Owner
+    const guesses = infer(flags.app)
+    const questions: (InputQuestion | ListQuestion)[] = []
+
+    const app = flags.app
+
+    if (args.name) {
+      name = args.name
+    } else {
+      questions.push({
+        type: 'input',
+        name: 'name',
+        message: 'Pipeline name',
+        default: guesses[0],
+      })
+    }
+
+    if (flags.stage) {
+      stage = flags.stage
+    } else {
+      questions.push({
+        type: 'list',
+        name: 'stage',
+        message: `Stage of ${app}`,
+        choices: stages,
+        default: guesses[1],
+      })
+    }
+
+    const teamName = flags.team
+    const ownerType = teamName ? 'team' : 'user'
+
+    // If team or org is not specified, we assign ownership to the user creating
+    const response = teamName ? await getTeam(this.heroku, teamName) : await getAccountInfo(this.heroku)
+    owner = response.body
+    const ownerID = owner.id
+
+    owner = {id: ownerID, type: ownerType}
+
+    const answers: Answers = await prompt(questions)
+    if (answers.name) name = answers.name
+    if (answers.stage) stage = answers.stage
+
+    ux.action.start(`Creating ${name} pipeline`)
+    const generation = await getGenerationByAppId(app, this.heroku)
+    const {body: pipeline} = await createPipeline(this.heroku, name, owner, generation)
+    ux.action.stop()
+
+    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/destroy.d.ts

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

package/lib/oldCommands/pipelines/destroy.js

@@ -0,0 +1,34 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command} from '@heroku-cli/command'
+import * as Heroku from '@heroku-cli/schema'
+import {Args, ux} from '@oclif/core'
+
+import {destroyPipeline} from '../../lib/api'
+import disambiguate from '../../lib/pipelines/disambiguate'
+
+export default class PipelinesDestroy extends Command {
+  static description = 'destroy a pipeline'
+
+  static examples = [
+    '$ heroku pipelines:destroy my-pipeline',
+  ]
+
+  static args = {
+    pipeline: Args.string({
+      description: 'name of pipeline',
+      required: true,
+    }),
+  }
+
+  async run() {
+    const {args} = await this.parse(PipelinesDestroy)
+    const pipeline: Heroku.Pipeline = await disambiguate(this.heroku, args.pipeline)
+
+    ux.action.start(`Destroying ${color.pipeline(pipeline.name!)} pipeline`)
+    await destroyPipeline(this.heroku, pipeline.name, pipeline.id)
+    ux.action.stop()
+  }
+}
+*/

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

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

package/lib/oldCommands/pipelines/diff.js

@@ -0,0 +1,202 @@
+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 HTTP from '@heroku/http-call'
+
+import {getCoupling, getPipeline, getReleases, listPipelineApps, SDK_HEADER} from '../../lib/api'
+import KolkrabbiAPI from '../../lib/pipelines/kolkrabbi-api'
+import type {OciImage, Slug, PipelineCoupling} from '../../lib/types/fir'
+import type {Commit, GitHubDiff} from '../../lib/types/github'
+import {GenerationKind, getGeneration} from '../../lib/apps/generation'
+
+interface AppInfo {
+  name: string;
+  repo?: string;
+  hash?: string;
+}
+
+const PROMOTION_ORDER = ['development', 'staging', 'production']
+
+async function diff(targetApp: AppInfo, downstreamApp: AppInfo, githubToken: string, herokuUserAgent: string) {
+  if (!downstreamApp.repo) {
+    return ux.log(`\n${color.app(targetApp.name)} was not compared to ${color.app(downstreamApp.name)} as ${color.app(downstreamApp.name)} is not connected to GitHub`)
+  }
+
+  if (downstreamApp.repo !== targetApp.repo) {
+    return ux.log(`\n${color.app(targetApp.name)} was not compared to ${color.app(downstreamApp.name)} as ${color.app(downstreamApp.name)} is not connected to the same GitHub repo as ${color.app(targetApp.name)}`)
+  }
+
+  if (!downstreamApp.hash) {
+    return ux.log(`\n${color.app(targetApp.name)} was not compared to ${color.app(downstreamApp.name)} as ${color.app(downstreamApp.name)} does not have any releases`)
+  }
+
+  if (downstreamApp.hash === targetApp.hash) {
+    return ux.log(`\n${color.app(targetApp.name)} is up to date with ${color.app(downstreamApp.name)}`)
+  }
+
+  // Do the actual GitHub diff
+  try {
+    const path = `${targetApp.repo}/compare/${downstreamApp.hash}...${targetApp.hash}`
+    const headers = {
+      authorization: 'token ' + githubToken,
+      'Content-Type': 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+    }
+
+    if (herokuUserAgent) {
+      Reflect.set(headers, 'user-agent', herokuUserAgent)
+    }
+
+    const {body: githubDiff} = await HTTP.get<GitHubDiff>(`https://api.github.com/repos/${path}`, {headers})
+
+    ux.log('')
+    hux.styledHeader(`${color.app(targetApp.name)} is ahead of ${color.app(downstreamApp.name)} by ${githubDiff.ahead_by} commit${githubDiff.ahead_by === 1 ? '' : 's'}`)
+    const mapped = githubDiff.commits.map((commit: Commit) => {
+      return {
+        sha: commit.sha.slice(0, 7),
+        date: commit.commit.author.date,
+        author: commit.commit.author.name,
+        message: commit.commit.message.split('\n')[0],
+      }
+    }).reverse()
+    hux.table(mapped, {
+      sha: {
+        header: 'SHA',
+      },
+      date: {},
+      author: {},
+      message: {},
+    })
+    ux.log(`\nhttps://github.com/${path}`)
+  } catch {
+    ux.log(`\n${color.app(targetApp.name)} was not compared to ${color.app(downstreamApp.name)} because we were unable to perform a diff`)
+    ux.log('are you sure you have pushed your latest commits to GitHub?')
+  }
+}
+
+export default class PipelinesDiff extends Command {
+  static description = 'compares the latest release of this app to its downstream app(s)'
+
+  static examples = [
+    '$ heroku pipelines:diff -a my-app-staging',
+  ]
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  kolkrabbi: KolkrabbiAPI = new KolkrabbiAPI(this.config.userAgent, () => this.heroku.auth)
+
+  getAppInfo = async (appName: string, appId: string, generation: GenerationKind): Promise<AppInfo> => {
+    // Find GitHub connection for the app
+    const githubApp = await this.kolkrabbi.getAppLink(appId)
+      .catch(() => {
+        return {name: appName, repo: null, hash: null}
+      })
+
+    // Find the commit hash of the latest release for this app
+    let slug: Slug
+    let ociImages: Array<OciImage>
+    let commit: string | undefined
+
+    try {
+      const {body: releases} = await getReleases(this.heroku, appId)
+      const release = releases.find(r => r.status === 'succeeded')
+      if (!release || !(release.slug || release.oci_image)) {
+        throw new Error(`no release found for ${appName}`)
+      }
+
+      if (generation === 'cedar' && release.slug) {
+        slug = await this.heroku.get<Slug>(`/apps/${appId}/slugs/${release.slug.id}`, {
+          headers: {Accept: SDK_HEADER},
+        }).then(res => res.body)
+        commit = slug.commit!
+      } else if (generation === 'fir' && release.oci_image) {
+        ociImages = await this.heroku.get<Array<OciImage>>(`/apps/${appId}/oci-images/${release.oci_image.id}`, {
+          headers: {Accept: SDK_HEADER},
+        }).then(res => res.body)
+        commit = ociImages[0]?.commit
+      }
+    } catch {
+      return {name: appName, repo: githubApp.repo, hash: undefined}
+    }
+
+    return {name: appName, repo: githubApp.repo, hash: commit}
+  }
+
+  async run() {
+    const {flags} = await this.parse(PipelinesDiff)
+    const targetAppName = flags.app
+
+    let coupling: PipelineCoupling | undefined
+    try {
+      ({body: coupling} = await getCoupling(this.heroku, targetAppName))
+    } catch {
+      ux.error(`This app (${targetAppName}) does not seem to be a part of any pipeline`)
+      return
+    }
+
+    const {body: pipeline} = await getPipeline(this.heroku, coupling.pipeline!.id!)
+
+    const targetAppId = coupling!.app!.id!
+    const generation = getGeneration(pipeline)!
+
+    ux.action.start('Fetching apps from pipeline')
+    const allApps = await listPipelineApps(this.heroku, coupling!.pipeline!.id!)
+    ux.action.stop()
+
+    const sourceStage = coupling.stage
+
+    if (!sourceStage) {
+      return ux.error(`Unable to diff ${targetAppName}`)
+    }
+
+    const downstreamStage = PROMOTION_ORDER[PROMOTION_ORDER.indexOf(sourceStage) + 1]
+    if (!downstreamStage || !PROMOTION_ORDER.includes(sourceStage)) {
+      return ux.error(`Unable to diff ${targetAppName}`)
+    }
+
+    const downstreamApps = allApps.filter(app => app.pipelineCoupling.stage === downstreamStage)
+
+    if (downstreamApps.length === 0) {
+      return ux.error(`Cannot diff ${targetAppName} as there are no downstream apps configured`)
+    }
+
+    // Fetch GitHub repo/latest release hash for [target, downstream[0], .., downstream[n]] apps
+    const appInfoPromises = [this.getAppInfo(targetAppName, targetAppId, generation)]
+    downstreamApps.forEach(app => {
+      if (app.name && app.id) {
+        appInfoPromises.push(this.getAppInfo(app.name, app.id, generation))
+      }
+    })
+    ux.action.start('Fetching release info for all apps')
+    const appInfo = await Promise.all(appInfoPromises)
+    ux.action.stop()
+
+    // Verify the target app
+    const targetAppInfo = appInfo[0]
+    if (!targetAppInfo.repo) {
+      const command = `heroku pipelines:open ${coupling.pipeline!.name}`
+      return ux.error(`${targetAppName} does not seem to be connected to GitHub!\nRun ${color.cyan(command)} and "Connect to GitHub".`)
+    }
+
+    if (!targetAppInfo.hash) {
+      return ux.error(`No release was found for ${targetAppName}, unable to diff`)
+    }
+
+    // Fetch GitHub token for the user
+    const githubAccount = await this.kolkrabbi.getAccount()
+    // Diff [{target, downstream[0]}, {target, downstream[1]}, .., {target, downstream[n]}]
+    const downstreamAppsInfo = appInfo.slice(1)
+    for (const downstreamAppInfo of downstreamAppsInfo) {
+      await diff(
+        targetAppInfo, downstreamAppInfo, githubAccount.github.token, this.config.userAgent,
+      )
+    }
+  }
+}
+*/

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

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

package/lib/oldCommands/pipelines/index.js

@@ -0,0 +1,34 @@
+export {};
+/*
+import {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'
+
+export default class Pipelines extends Command {
+  static description = 'list pipelines you have access to'
+
+  static examples = [
+    '$ heroku pipelines',
+  ]
+
+  static flags = {
+    json: flags.boolean({description: 'output in json format'}),
+  }
+
+  async run() {
+    const {flags} = await this.parse(Pipelines)
+
+    const {body: pipelines} = await this.heroku.get<Heroku.Pipeline[]>('/pipelines')
+
+    if (flags.json) {
+      hux.styledJSON(pipelines)
+    } else {
+      hux.styledHeader('My Pipelines')
+      for (const pipeline of pipelines) {
+        ux.log(pipeline.name)
+      }
+    }
+  }
+}
+*/

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

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

package/lib/oldCommands/pipelines/info.js

@@ -0,0 +1,51 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import * as Heroku from '@heroku-cli/schema'
+import {Args} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+
+import {listPipelineApps} from '../../lib/api'
+import disambiguate from '../../lib/pipelines/disambiguate'
+import renderPipeline from '../../lib/pipelines/render-pipeline'
+
+export default class PipelinesInfo extends Command {
+  static description = 'show list of apps in a pipeline'
+
+  static examples = [
+    '$ heroku pipelines:info my-pipeline',
+  ]
+
+  static flags = {
+    json: flags.boolean({
+      description: 'output in json format',
+    }),
+    'with-owners': flags.boolean({
+      description: 'shows owner of every app',
+      hidden: true,
+    }),
+  }
+
+  static args = {
+    pipeline: Args.string({
+      description: 'pipeline to show list of apps for',
+      required: true,
+    }),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(PipelinesInfo)
+    const pipeline: Heroku.Pipeline = await disambiguate(this.heroku, args.pipeline)
+    const pipelineApps = await listPipelineApps(this.heroku, pipeline.id!)
+
+    if (flags.json) {
+      hux.styledJSON({pipeline, apps: pipelineApps})
+    } else {
+      await renderPipeline(this.heroku, pipeline, pipelineApps, {
+        withOwners: flags['with-owners'],
+        showOwnerWarning: true,
+      })
+    }
+  }
+}
+*/

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

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

package/lib/oldCommands/pipelines/open.js

@@ -0,0 +1,25 @@
+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

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