heroku 11.0.0-alpha.11 → 11.0.0-alpha.12

package/lib/lib/autocomplete/completions.js

@@ -1,295 +1,263 @@
-export {};
-/*
-import {APIClient} from '@heroku-cli/command'
-import {deps} from '@heroku-cli/command/lib/deps'
-import {configRemote, getGitRemotes} from '@heroku-cli/command/lib/git'
-import {Completion, CompletionContext} from '@oclif/core/lib/interfaces/parser'
-import * as path from 'path'
-import {flatten} from 'lodash'
-
-export const oneDay = 60 * 60 * 24
-
-export const herokuGet = async (resource: string, ctx: CompletionContext): Promise<string[]> => {
-  const heroku = new APIClient(ctx.config)
-  let {body} = await heroku.get(`/${resource}`, {retryAuth: false})
-  if (typeof body === 'string') body = JSON.parse(body)
-  return (body as any[]).map((a: any) => a.name).sort()
-}
-
-export const AppCompletion: Completion = {
-  cacheDuration: oneDay,
-  options: async ctx => {
-    const teams = await herokuGet('teams', ctx)
-    const apps = {
-      personal: await herokuGet('users/~/apps', ctx),
-      teams: flatten(await Promise.all(teams.map((team: string) => herokuGet(`teams/${team}/apps`, ctx)))),
+import { APIClient } from '@heroku-cli/command';
+import { configRemote, getGitRemotes } from '@heroku-cli/command/lib/git.js';
+import fs from 'fs-extra';
+import pkg from 'lodash';
+import * as path from 'path';
+const { flatten } = pkg;
+export const oneDay = 60 * 60 * 24;
+export const herokuGet = async (resource, ctx) => {
+    const heroku = new APIClient(ctx.config);
+    let { body } = await heroku.get(`/${resource}`, { retryAuth: false });
+    if (typeof body === 'string')
+        body = JSON.parse(body);
+    return body.map((a) => a.name).sort();
+};
+export const AppCompletion = {
+    cacheDuration: oneDay,
+    async options(ctx) {
+        const teams = await herokuGet('teams', ctx);
+        const apps = {
+            personal: await herokuGet('users/~/apps', ctx),
+            teams: flatten(await Promise.all(teams.map((team) => herokuGet(`teams/${team}/apps`, ctx)))),
+        };
+        return apps.personal.concat(apps.teams);
+    },
+};
+export const AppAddonCompletion = {
+    cacheDuration: oneDay,
+    async cacheKey(ctx) {
+        return ctx.flags && ctx.flags.app ? `${ctx.flags.app}_addons` : '';
+    },
+    async options(ctx) {
+        const addons = ctx.flags && ctx.flags.app ? await herokuGet(`apps/${ctx.flags.app}/addons`, ctx) : [];
+        return addons;
+    },
+};
+export const AppDynoCompletion = {
+    cacheDuration: oneDay,
+    async cacheKey(ctx) {
+        return ctx.flags && ctx.flags.app ? `${ctx.flags.app}_dynos` : '';
+    },
+    async options(ctx) {
+        const dynos = ctx.flags && ctx.flags.app ? await herokuGet(`apps/${ctx.flags.app}/dynos`, ctx) : [];
+        return dynos;
+    },
+};
+export const BuildpackCompletion = {
+    async options() {
+        return [
+            'heroku/ruby',
+            'heroku/nodejs',
+            'heroku/clojure',
+            'heroku/python',
+            'heroku/java',
+            'heroku/gradle',
+            'heroku/scala',
+            'heroku/php',
+            'heroku/go',
+        ];
+    },
+    skipCache: true,
+};
+const ConfigCompletion = {
+    cacheDuration: 60 * 60 * 24 * 7,
+    async cacheKey(ctx) {
+        return ctx.flags && ctx.flags.app ? `${ctx.flags.app}_config_vars` : '';
+    },
+    async options(ctx) {
+        const heroku = new APIClient(ctx.config);
+        if (ctx.flags && ctx.flags.app) {
+            const { body: configs } = await heroku.get(`/apps/${ctx.flags.app}/config-vars`, { retryAuth: false });
+            return Object.keys(configs);
+        }
+        return [];
+    },
+};
+const ConfigSetCompletion = {
+    cacheDuration: 60 * 60 * 24 * 7,
+    async cacheKey(ctx) {
+        return ctx.flags && ctx.flags.app ? `${ctx.flags.app}_config_set_vars` : '';
+    },
+    async options(ctx) {
+        const heroku = new APIClient(ctx.config);
+        if (ctx.flags && ctx.flags.app) {
+            const { body: configs } = await heroku.get(`/apps/${ctx.flags.app}/config-vars`, { retryAuth: false });
+            return Object.keys(configs).map(k => `${k}=`);
+        }
+        return [];
+    },
+};
+export const DynoSizeCompletion = {
+    cacheDuration: oneDay * 90,
+    async options(ctx) {
+        let sizes = await herokuGet('dyno-sizes', ctx);
+        if (sizes)
+            sizes = sizes.map(s => s.toLowerCase());
+        return sizes;
+    },
+};
+export const FileCompletion = {
+    async options() {
+        const files = await fs.readdir(process.cwd());
+        return files;
+    },
+    skipCache: true,
+};
+export const PipelineCompletion = {
+    cacheDuration: oneDay,
+    async options(ctx) {
+        const pipelines = await herokuGet('pipelines', ctx);
+        return pipelines;
+    },
+};
+export const ProcessTypeCompletion = {
+    async options() {
+        let types = [];
+        const procfile = path.join(process.cwd(), 'Procfile');
+        try {
+            const buff = await fs.readFile(procfile);
+            types = buff
+                .toString()
+                .split('\n')
+                .map((s) => {
+                if (!s)
+                    return false;
+                const m = s.match(/^([A-Za-z0-9_-]+)/);
+                return m ? m[0] : false;
+            })
+                .filter((t) => t !== false);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        return types;
+    },
+    skipCache: true,
+};
+export const ProtocolCompletion = {
+    cacheDuration: 60 * 60 * 24 * 365,
+    async options() {
+        return ['tcp', 'udp', 'icmp', '0-255', 'any'];
+    },
+};
+export const RegionCompletion = {
+    cacheDuration: oneDay * 7,
+    async options(ctx) {
+        const regions = await herokuGet('regions', ctx);
+        return regions;
+    },
+};
+export const RemoteCompletion = {
+    async options() {
+        const remotes = getGitRemotes(configRemote());
+        return remotes.map((r) => r.remote);
+    },
+    skipCache: true,
+};
+export const RoleCompletion = {
+    async options() {
+        return ['admin', 'collaborator', 'member', 'owner'];
+    },
+    skipCache: true,
+};
+export const ScopeCompletion = {
+    async options() {
+        return ['global', 'identity', 'read', 'write', 'read-protected', 'write-protected'];
+    },
+    skipCache: true,
+};
+export const SpaceCompletion = {
+    cacheDuration: oneDay,
+    async options(ctx) {
+        const spaces = await herokuGet('spaces', ctx);
+        return spaces;
+    },
+};
+export const StackCompletion = {
+    cacheDuration: oneDay,
+    async options(ctx) {
+        const stacks = await herokuGet('stacks', ctx);
+        return stacks;
+    },
+};
+export const StageCompletion = {
+    async options() {
+        return ['test', 'review', 'development', 'staging', 'production'];
+    },
+    skipCache: true,
+};
+export const TeamCompletion = {
+    cacheDuration: oneDay,
+    async options(ctx) {
+        const teams = await herokuGet('teams', ctx);
+        return teams;
+    },
+};
+export const CompletionMapping = {
+    addon: AppAddonCompletion,
+    app: AppCompletion,
+    buildpack: BuildpackCompletion,
+    config: ConfigCompletion,
+    configSet: ConfigSetCompletion,
+    dyno: AppDynoCompletion,
+    dynosize: DynoSizeCompletion,
+    pipeline: PipelineCompletion,
+    processtype: ProcessTypeCompletion,
+    region: RegionCompletion,
+    remote: RemoteCompletion,
+    role: RoleCompletion,
+    scope: ScopeCompletion,
+    space: SpaceCompletion,
+    stack: StackCompletion,
+    stage: StageCompletion,
+    team: TeamCompletion,
+};
+export class CompletionLookup {
+    cmdId;
+    name;
+    description;
+    blocklistMap = {
+        app: ['apps:create'],
+        space: ['spaces:create'],
+    };
+    commandArgsMap = {
+        key: {
+            'config:set': 'configSet',
+        },
+    };
+    keyAliasMap = {
+        key: {
+            'config:get': 'config',
+        },
+    };
+    constructor(cmdId, name, description) {
+        this.cmdId = cmdId;
+        this.name = name;
+        this.description = description;
     }
-    return apps.personal.concat(apps.teams)
-  },
-}
-
-export const AppAddonCompletion: Completion = {
-  cacheDuration: oneDay,
-  cacheKey: async ctx => {
-    return ctx.flags && ctx.flags.app ? `${ctx.flags.app}_addons` : ''
-  },
-  options: async ctx => {
-    const addons = ctx.flags && ctx.flags.app ? await herokuGet(`apps/${ctx.flags.app}/addons`, ctx) : []
-    return addons
-  },
-}
-
-export const AppDynoCompletion: Completion = {
-  cacheDuration: oneDay,
-  cacheKey: async ctx => {
-    return ctx.flags && ctx.flags.app ? `${ctx.flags.app}_dynos` : ''
-  },
-  options: async ctx => {
-    const dynos = ctx.flags && ctx.flags.app ? await herokuGet(`apps/${ctx.flags.app}/dynos`, ctx) : []
-    return dynos
-  },
-}
-
-export const BuildpackCompletion: Completion = {
-  skipCache: true,
-
-  options: async () => {
-    return [
-      'heroku/ruby',
-      'heroku/nodejs',
-      'heroku/clojure',
-      'heroku/python',
-      'heroku/java',
-      'heroku/gradle',
-      'heroku/scala',
-      'heroku/php',
-      'heroku/go',
-    ]
-  },
-}
-
-const ConfigCompletion: Completion = {
-  cacheDuration: 60 * 60 * 24 * 7,
-  cacheKey: async (ctx: any) => {
-    return ctx.flags && ctx.flags.app ? `${ctx.flags.app}_config_vars` : ''
-  },
-  options: async (ctx: any) => {
-    const heroku = new APIClient(ctx.config)
-    if (ctx.flags && ctx.flags.app) {
-      const {body: configs} = await heroku.get<{body: Record<string,  any>}>(`/apps/${ctx.flags.app}/config-vars`, {retryAuth: false})
-      return Object.keys(configs)
+    run() {
+        if (this.blocklisted())
+            return;
+        return CompletionMapping[this.key];
     }
-
-    return []
-  },
-}
-
-const ConfigSetCompletion: Completion = {
-  cacheDuration: 60 * 60 * 24 * 7,
-  cacheKey: async (ctx: any) => {
-    return ctx.flags && ctx.flags.app ? `${ctx.flags.app}_config_set_vars` : ''
-  },
-  options: async (ctx: any) => {
-    const heroku = new APIClient(ctx.config)
-    if (ctx.flags && ctx.flags.app) {
-      const {body: configs} = await heroku.get<{body: Record<string,  any>}>(`/apps/${ctx.flags.app}/config-vars`, {retryAuth: false})
-      return Object.keys(configs).map(k => `${k}=`)
+    argAlias() {
+        return this.commandArgsMap[this.name] && this.commandArgsMap[this.name][this.cmdId];
     }
-
-    return []
-  },
-}
-
-export const DynoSizeCompletion: Completion = {
-  cacheDuration: oneDay * 90,
-  options: async ctx => {
-    let sizes = await herokuGet('dyno-sizes', ctx)
-    if (sizes) sizes = sizes.map(s => s.toLowerCase())
-    return sizes
-  },
-}
-
-export const FileCompletion: Completion = {
-  skipCache: true,
-
-  options: async () => {
-    const files = await deps.file.readdir(process.cwd())
-    return files
-  },
-}
-
-export const PipelineCompletion: Completion = {
-  cacheDuration: oneDay,
-  options: async ctx => {
-    const pipelines = await herokuGet('pipelines', ctx)
-    return pipelines
-  },
-}
-
-export const ProcessTypeCompletion: Completion = {
-  skipCache: true,
-
-  options: async () => {
-    let types: string[] = []
-    const procfile = path.join(process.cwd(), 'Procfile')
-    try {
-      const buff = await deps.file.readFile(procfile)
-      types = buff
-        .toString()
-        .split('\n')
-        .map(s => {
-          if (!s) return false
-          const m = s.match(/^([A-Za-z0-9_-]+)/)
-          return m ? m[0] : false
-        })
-        .filter(t => t) as string[]
-    } catch (error: any) {
-      if (error.code !== 'ENOENT') throw error
+    blocklisted() {
+        return this.blocklistMap[this.name] && this.blocklistMap[this.name].includes(this.cmdId);
+    }
+    descriptionAlias() {
+        const d = this.description;
+        if (d.match(/^dyno size/))
+            return 'dynosize';
+        if (d.match(/^process type/))
+            return 'processtype';
+    }
+    get key() {
+        return this.argAlias() || this.keyAlias() || this.descriptionAlias() || this.name;
+    }
+    keyAlias() {
+        return this.keyAliasMap[this.name] && this.keyAliasMap[this.name][this.cmdId];
     }
-
-    return types
-  },
-}
-
-export const ProtocolCompletion = {
-  cacheDuration: 60 * 60 * 24 * 365, options: async () => {
-    return ['tcp', 'udp', 'icmp', '0-255', 'any']
-  },
-}
-
-export const RegionCompletion: Completion = {
-  cacheDuration: oneDay * 7,
-  options: async ctx => {
-    const regions = await herokuGet('regions', ctx)
-    return regions
-  },
-}
-
-export const RemoteCompletion: Completion = {
-  skipCache: true,
-
-  options: async () => {
-    const remotes = getGitRemotes(configRemote())
-    return remotes.map(r => r.remote)
-  },
-}
-
-export const RoleCompletion: Completion = {
-  skipCache: true,
-
-  options: async () => {
-    return ['admin', 'collaborator', 'member', 'owner']
-  },
-}
-
-export const ScopeCompletion: Completion = {
-  skipCache: true,
-
-  options: async () => {
-    return ['global', 'identity', 'read', 'write', 'read-protected', 'write-protected']
-  },
-}
-
-export const SpaceCompletion: Completion = {
-  cacheDuration: oneDay,
-  options: async ctx => {
-    const spaces = await herokuGet('spaces', ctx)
-    return spaces
-  },
-}
-
-export const StackCompletion: Completion = {
-  cacheDuration: oneDay,
-  options: async ctx => {
-    const stacks = await herokuGet('stacks', ctx)
-    return stacks
-  },
-}
-
-export const StageCompletion: Completion = {
-  skipCache: true,
-
-  options: async () => {
-    return ['test', 'review', 'development', 'staging', 'production']
-  },
-}
-
-export const TeamCompletion: Completion = {
-  cacheDuration: oneDay,
-  options: async ctx => {
-    const teams = await herokuGet('teams', ctx)
-    return teams
-  },
-}
-
-export const CompletionMapping: { [key: string]: Completion } = {
-  app: AppCompletion,
-  addon: AppAddonCompletion,
-  dyno: AppDynoCompletion,
-  buildpack: BuildpackCompletion,
-  config: ConfigCompletion,
-  configSet: ConfigSetCompletion,
-  dynosize: DynoSizeCompletion,
-  pipeline: PipelineCompletion,
-  processtype: ProcessTypeCompletion,
-  region: RegionCompletion,
-  remote: RemoteCompletion,
-  role: RoleCompletion,
-  scope: ScopeCompletion,
-  space: SpaceCompletion,
-  stack: StackCompletion,
-  stage: StageCompletion,
-  team: TeamCompletion,
-}
-
-export class CompletionLookup {
-  private get key(): string {
-    return this.argAlias() || this.keyAlias() || this.descriptionAlias() || this.name
-  }
-
-  private readonly blocklistMap: { [key: string]: string[] } = {
-    app: ['apps:create'],
-    space: ['spaces:create'],
-  }
-
-  private readonly keyAliasMap: { [key: string]: { [key: string]: string } } = {
-    key: {
-      'config:get': 'config',
-    },
-  }
-
-  private readonly commandArgsMap: { [key: string]: { [key: string]: string } } = {
-    key: {
-      'config:set': 'configSet',
-    },
-  }
-
-  // eslint-disable-next-line no-useless-constructor
-  constructor(private readonly cmdId: string, private readonly name: string, private readonly description?: string) {}
-
-  run(): Completion | undefined {
-    if (this.blocklisted()) return
-    return CompletionMapping[this.key]
-  }
-
-  private argAlias(): string | undefined {
-    return this.commandArgsMap[this.name] && this.commandArgsMap[this.name][this.cmdId]
-  }
-
-  private keyAlias(): string | undefined {
-    return this.keyAliasMap[this.name] && this.keyAliasMap[this.name][this.cmdId]
-  }
-
-  private descriptionAlias(): string | undefined {
-    const d = this.description!
-    // eslint-disable-next-line unicorn/prefer-starts-ends-with
-    if (d.match(/^dyno size/)) return 'dynosize'
-    // eslint-disable-next-line unicorn/prefer-starts-ends-with
-    if (d.match(/^process type/)) return 'processtype'
-  }
-
-  private blocklisted(): boolean {
-    return this.blocklistMap[this.name] && this.blocklistMap[this.name].includes(this.cmdId)
-  }
 }
-*/

package/lib/lib/buildpacks/buildpacks.d.ts

@@ -1,9 +1,9 @@
-import { APIClient } from '@heroku-cli/command';
 import { BuildpackRegistry } from '@heroku/buildpack-registry';
+import { APIClient } from '@heroku-cli/command';
 export declare type BuildpackResponse = {
     buildpack: {
-        url: string;
         name: string;
+        url: string;
     };
     ordinal: number;
 };
@@ -11,20 +11,20 @@ export declare class BuildpackCommand {
     heroku: APIClient;
     registry: BuildpackRegistry;
     constructor(heroku: APIClient);
-    fetch(app: string, isFirApp?: boolean): Promise<any[]>;
-    mapBuildpackResponse(buildpacks: BuildpackResponse[]): BuildpackResponse[];
+    clear(app: string, command: 'clear' | 'remove', action: 'cleared' | 'removed'): Promise<void>;
     display(buildpacks: BuildpackResponse[], indent: string): void;
-    registryNameToUrl(buildpack: string): Promise<string>;
-    findUrl(buildpacks: BuildpackResponse[], buildpack: string): Promise<number>;
-    validateUrlNotSet(buildpacks: BuildpackResponse[], buildpack: string): Promise<void>;
+    displayUpdate(app: string, remote: string, buildpacks: BuildpackResponse[], action: 'added' | 'removed' | 'set'): void;
+    fetch(app: string, isFirApp?: boolean): Promise<any[]>;
     findIndex(buildpacks: BuildpackResponse[], index?: number): number;
-    mutate(app: string, buildpacks: BuildpackResponse[], spliceIndex: number, buildpack: string, command: 'add' | 'set' | 'remove'): Promise<BuildpackResponse[]>;
+    findUrl(buildpacks: BuildpackResponse[], buildpack: string): Promise<number>;
+    mapBuildpackResponse(buildpacks: BuildpackResponse[]): BuildpackResponse[];
+    mutate(app: string, buildpacks: BuildpackResponse[], spliceIndex: number, buildpack: string, command: 'add' | 'remove' | 'set'): Promise<BuildpackResponse[]>;
     put(app: string, buildpackUpdates: {
         buildpack: string;
     }[]): Promise<BuildpackResponse[]>;
-    displayUpdate(app: string, remote: string, buildpacks: BuildpackResponse[], action: 'added' | 'set' | 'removed'): void;
+    registryNameToUrl(buildpack: string): Promise<string>;
     registryUrlToName(buildpack: string, registryOnly?: boolean): string;
-    clear(app: string, command: 'clear' | 'remove', action: 'cleared' | 'removed'): Promise<void>;
-    validateIndexInRange(buildpacks: BuildpackResponse[], index: number): void;
     validateIndex(index: number): void;
+    validateIndexInRange(buildpacks: BuildpackResponse[], index: number): void;
+    validateUrlNotSet(buildpacks: BuildpackResponse[], buildpack: string): Promise<void>;
 }