@optimizely/ocp-cli 1.0.0-beta.2

package/src/commands/app/Register.ts

@@ -0,0 +1,41 @@
+import {command, flag, help, namespace, option, param} from 'oo-cli';
+import {die} from '../../lib/die';
+import {formatError} from '../../lib/formatError';
+import {Rivendell} from '../../lib/Rivendell';
+import {applicableShards} from '../../lib/Shards';
+
+@namespace('app')
+export class RegisterCommand {
+  @param
+  @help('The app id to reserve')
+  public id!: string;
+
+  @param
+  @help('The display name of the app')
+  public name!: string;
+
+  @flag
+  @help(
+    'Do not share this app with other developers in your organization. ' +
+    'If not set, the app will be shared with all developers in your organization'
+  )
+  public personal: boolean = false;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command
+  @help('Register an app version')
+  public async register() {
+    try {
+      const shards = await applicableShards(this.availability);
+      for (const shard of shards) {
+        const app = await Rivendell.registerApp(this.id, this.name, this.personal, shard);
+        console.log(`Registered app ${app.id} with name "${app.name} in ${shard}`);
+      }
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+}

package/src/commands/app/Validate.ts

@@ -0,0 +1,13 @@
+import chalk from 'chalk';
+import {command, help, namespace} from 'oo-cli';
+import {BaseBuildCommand} from './BaseBuildCommand';
+
+@namespace('app')
+export class ValidateCommand extends BaseBuildCommand {
+  @command
+  @help('Validate an app locally')
+  public async validate() {
+    await this.run(false, false, false);
+    console.log(chalk.gray(`\nUse ${chalk.white('ocp app prepare')} to upload and build your app\n`));
+  }
+}

package/src/commands/availability/List.ts

@@ -0,0 +1,37 @@
+import {command, help, namespace} from 'oo-cli';
+import {die} from '../../lib/die';
+import {formatError} from '../../lib/formatError';
+import {Rivendell} from '../../lib/Rivendell';
+import Shard = Rivendell.Shard;
+import chalk from 'chalk';
+import * as table from 'text-table';
+import {styledStringLength} from '../../lib/StringUtils';
+
+@namespace('availability')
+export class ListCommand {
+  @command
+  @help('List all availability zones')
+  public async list() {
+    try {
+      this.render(await Rivendell.shards());
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+
+  private render(accounts: Shard[]) {
+    const header = ['Name', 'Description'].map((item) => chalk.grey(item));
+    const rows = accounts.map((shard) => [shard.id, shard.description]);
+    const t = table(
+      [
+        header,
+        ...rows
+      ],
+      {
+        hsep: ' '.repeat(8),
+        stringLength: styledStringLength
+      }
+    );
+    console.log(`\n${t}\n`);
+  }
+}

package/src/commands/directory/Info.ts

@@ -0,0 +1,83 @@
+import chalk from 'chalk';
+import {command, help, namespace, option, param} from 'oo-cli';
+import {die} from '../../lib/die';
+import {formatVersionState} from '../../lib/formatVersionState';
+import {formatReviewStatus} from '../../lib/formatReviewStatus';
+import {formatError} from '../../lib/formatError';
+import {Rivendell} from '../../lib/Rivendell';
+import * as table from 'text-table';
+import {styledStringLength} from '../../lib/StringUtils';
+import SortDirection = Rivendell.SortDirection;
+import AppVersion = Rivendell.AppVersion;
+import AppVersionState = Rivendell.AppVersionState;
+import App = Rivendell.App;
+import ReviewStatus = Rivendell.ReviewStatus;
+
+@namespace('directory')
+export class InfoCommand {
+  @param
+  @help('The App ID to look up')
+  public appId!: string;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command
+  @help('Get information about an app')
+  public async info() {
+    try {
+      await this.render(await Rivendell.fetchApp(this.appId, this.availability));
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+
+  private async render(app: App): Promise<void> {
+    console.log('');
+    console.log(`  ${chalk.bold.underline('General')}\n`);
+    console.log(`    ${chalk.cyanBright('id')}\t\t${app.id}`);
+    console.log(`    ${chalk.cyanBright('name')}\t${app.name}`);
+    console.log(`    ${chalk.cyanBright('created')}\t${app.createdAt}`);
+    console.log('');
+
+    // Versions
+    console.log(`  ${chalk.bold.underline('Versions')}\n`);
+    const versions = await this.fetchAppVersions();
+    if (!versions) {
+      console.log(`  ${chalk.italic('None')}`);
+    } else {
+      const rows = versions.map((appVersion) => {
+        const r = [
+          '',
+          appVersion.id.version,
+          formatVersionState(appVersion.state as AppVersionState)
+        ];
+        if (appVersion.reviewStatus) {
+          r.push(formatReviewStatus(appVersion.reviewStatus as ReviewStatus, appVersion.state as AppVersionState));
+        }
+        return r;
+      });
+      const t = table(rows, {
+          hsep: ' '.repeat(4),
+          stringLength: styledStringLength
+        }
+      );
+      console.log(`\n${t}\n`);
+    }
+  }
+
+  private async fetchAppVersions(): Promise<AppVersion[]> {
+    return await Rivendell.searchAppVersions(
+      {
+        appId: this.appId,
+        sorts: [
+          {
+            field: 'createdAt',
+            direction: SortDirection.DESC
+          }
+        ]
+      }, this.availability
+    );
+  }
+}

package/src/commands/directory/Install.ts

@@ -0,0 +1,37 @@
+import chalk from 'chalk';
+import {command, help, namespace, option, param} from 'oo-cli';
+import {die} from '../../lib/die';
+import {Rivendell} from '../../lib/Rivendell';
+import {formatError} from '../../lib/formatError';
+
+@namespace('directory')
+export class InstallCommand {
+  @param
+  @help('The App ID and version (e.g. my_app@1.0.0)')
+  public appVersion!: string;
+
+  @param
+  @help('The Tracker ID of the account to install into')
+  public trackerId!: string;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command
+  @help('Install a specific app version into an account')
+  public async install() {
+    if (!/[\w-]+@\d+\.\d+\.\d+(?:-\w+\.\d+)?/.test(this.appVersion)) {
+      return die('appVersion is required in the format of app@1.0.0');
+    }
+
+    const [appId, version] = this.appVersion.split('@');
+    try {
+      const install = await Rivendell.install(appId, version, this.trackerId, this.availability);
+      console.log(chalk.green(`Installed ${appId}@${version} for ${this.trackerId} ` +
+        `with install id ${install.id} in ${this.availability || 'us'}`));
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+}

package/src/commands/directory/List.ts

@@ -0,0 +1,96 @@
+import chalk from 'chalk';
+import {command, flag, help, namespace, option, optional, param} from 'oo-cli';
+import * as semver from 'semver';
+import * as table from 'text-table';
+import {die} from '../../lib/die';
+import {formatVersionState} from '../../lib/formatVersionState';
+import {styledStringLength} from '../../lib/StringUtils';
+import {Rivendell} from '../../lib/Rivendell';
+import {formatError} from '../../lib/formatError';
+import AppVersion = Rivendell.AppVersion;
+import AppVersionState = Rivendell.AppVersionState;
+import DeploymentStage = Rivendell.DeploymentStage;
+import AppVersionSearchCriteria = Rivendell.AppVersionSearchCriteria;
+import ReviewStatus = Rivendell.ReviewStatus;
+
+@namespace('directory')
+export class ListCommand {
+  @param
+  @optional
+  @help('A specific App ID to filter down to (lists all apps by default)')
+  private appId!: string;
+
+  @flag
+  @help('Include all statuses.  STOPPED is filtered by default')
+  private allStatuses: boolean = false;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command
+  @help('List registered app versions')
+  public async list(): Promise<void> {
+    try {
+      const criteria: AppVersionSearchCriteria = {
+        stages: [DeploymentStage.TEST, DeploymentStage.PRODUCTION]
+      };
+
+      if (this.appId) {
+        criteria.appId = this.appId;
+      }
+      this.render(await Rivendell.searchAppVersions(criteria, this.availability));
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+
+  private render(appVersions: AppVersion[]) {
+      const header = ['App ID', 'Version', 'State', 'Created At', 'Updated At'].map(
+        (item) => chalk.grey(item)
+      );
+      const rows = appVersions
+        .filter((appVersion) =>
+          this.allStatuses || appVersion.state as AppVersionState !== AppVersionState.STOPPED
+        )
+        .sort((lhs, rhs) => {
+          let result = lhs.id.appId.localeCompare(rhs.id.appId);
+          if (result === 0) {
+            const lhsVersion = lhs.id.version;
+            const rhsVersion = rhs.id.version;
+            if (lhsVersion !== rhsVersion) {
+              result = semver.gt(lhsVersion, rhsVersion) ? -1 : 1;
+            }
+          }
+          return result;
+        })
+        .map((appVersion) => [
+          appVersion.id.appId,
+          appVersion.id.version,
+          this.renderState(appVersion),
+          appVersion.createdAt,
+          appVersion.updatedAt
+        ]);
+
+      const t = table(
+        [
+          header,
+          ...rows
+        ],
+        {
+          hsep: ' '.repeat(8),
+          stringLength: styledStringLength
+        }
+      );
+      console.log(`\n${t}\n`);
+    }
+
+    private renderState(appVersion: AppVersion): string {
+      const state = appVersion.state as AppVersionState;
+      const reviewStatus = appVersion.reviewStatus as Rivendell.ReviewStatus;
+      const includeReviewStatus = reviewStatus === ReviewStatus.APPROVED || reviewStatus === ReviewStatus.IN_REVIEW;
+      return state === AppVersionState.PUBLISHED && includeReviewStatus
+        ? `${formatVersionState(state)} (${chalk.yellow(reviewStatus)})`
+        : formatVersionState(state);
+    }
+  }

package/src/commands/directory/ListFunctions.ts

@@ -0,0 +1,60 @@
+import chalk from 'chalk';
+import {command, help, namespace, option, param} from 'oo-cli';
+import {die} from '../../lib/die';
+import {formatError} from '../../lib/formatError';
+import {Rivendell} from '../../lib/Rivendell';
+import Webhook = Rivendell.Webhook;
+
+@namespace('directory')
+export class ListFunctionsCommand {
+  @param
+  @help('The App ID (e.g. my_app)')
+  public appId!: string;
+
+  @param
+  @help('The Tracker ID of the installed account')
+  public trackerId!: string;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command('list-functions')
+  @help('List the functions exposed by an app installation')
+  public async listFunctions() {
+    try {
+      const appInstallation = await Rivendell.fetchAppInstallation(this.appId, this.trackerId, this.availability);
+      const webhooks = await Rivendell.searchWebhooks({
+        appInstallId: appInstallation.id,
+        includeInternal: true,
+        includeDisabled: true
+      }, this.availability);
+
+      this.render(webhooks);
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+
+  private render(webhooks: Webhook[]) {
+    if (webhooks.length === 0) {
+      console.log(chalk.yellow(`${this.appId} install for ${this.trackerId} does not have functions.`));
+    } else {
+      webhooks.forEach((webhook) => {
+        const attrs = webhook.attributes!;
+        const caveats = [];
+        if (attrs.internal) {
+          caveats.push('internal');
+        }
+        if (!attrs.enabled) {
+          caveats.push('disabled');
+        }
+        if (caveats.length === 0) {
+          console.log(webhook.url);
+        } else {
+          console.log(chalk.yellow(`${webhook.url}  (${caveats.join(', ')})`));
+        }
+      });
+    }
+  }
+}

package/src/commands/directory/ListGlobalFunctions.ts

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import {command, help, namespace, option, param} from 'oo-cli';
+import {die} from '../../lib/die';
+import {Rivendell} from '../../lib/Rivendell';
+import {formatError} from '../../lib/formatError';
+import Webhook = Rivendell.Webhook;
+
+@namespace('directory')
+export class ListGlobalFunctionsCommand {
+  @param
+  @help('The App ID (e.g. my_app)')
+  public appId!: string;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command('list-global-functions')
+  @help('List the global functions exposed by an app')
+  public async listGlobalFunctions() {
+    try {
+      this.render(await Rivendell.searchWebhooks({
+        appId: this.appId,
+        appInstallId: 0,
+        includeInternal: true,
+        includeDisabled: true
+      }, this.availability));
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+
+  private render(webhooks: Webhook[]) {
+    if (webhooks.length === 0) {
+      console.log(chalk.yellow(`${this.appId} does not contain global functions.`));
+    } else {
+      webhooks.forEach((webhook) => {
+        const attrs = webhook.attributes;
+        const caveats = [];
+        if (attrs.internal) {
+          caveats.push('internal');
+        }
+        if (!attrs.enabled) {
+          caveats.push('disabled');
+        }
+        if (caveats.length === 0) {
+          console.log(webhook.url);
+        } else {
+          console.log(chalk.yellow(`${webhook.url}  (${caveats.join(', ')})`));
+        }
+      });
+    }
+  }
+}

package/src/commands/directory/ListInstalls.ts

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import {command, help, namespace, option, param} from 'oo-cli';
+import * as table from 'text-table';
+import {die} from '../../lib/die';
+import {styledStringLength} from '../../lib/StringUtils';
+import {Rivendell} from '../../lib/Rivendell';
+import {formatError} from '../../lib/formatError';
+import SortDirection = Rivendell.SortDirection;
+import AppInstallation = Rivendell.AppInstallation;
+
+@namespace('directory')
+export class ListInstallsCommand {
+  @param
+  @help('The App ID and optional version (e.g. my_app or my_app@1.0.0)')
+  public appVersion!: string;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command('list-installs')
+  @help('List installations of a specific app version')
+  public async listInstalls() {
+    const [appId, version] = this.appVersion.split('@');
+    try {
+      const appInstallations = await Rivendell.searchAppInstallations({
+          appId,
+          version,
+          sorts: [{
+            field: 'trackerId', direction: SortDirection.DESC
+          }]
+        },
+        this.availability
+      );
+
+      this.render(version, appInstallations);
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+
+  private render(version: string, appInstallations: AppInstallation[]) {
+    const header = this.getHeaders(version).map((item) => chalk.grey(item));
+    const rows = appInstallations.map((install) => this.getRow(install, version));
+    const t = table(
+      [
+        header,
+        ...rows
+      ],
+      {
+        hsep: ' '.repeat(8),
+        stringLength: styledStringLength
+      }
+    );
+    console.log(`\n${t}\n`);
+  }
+
+  private getHeaders(version: string): string[] {
+    const headers = ['Tracker', 'Created At', 'Updated At'];
+    if (!version) {
+      headers.splice(1, 0, 'Version');
+    }
+    return headers;
+  }
+
+  private getRow(install: AppInstallation, version: string): Array<{}> {
+    const row = [install.trackerId, install.createdAt, install.updatedAt];
+    if (!version) {
+      row.splice(1, 0, install.version);
+    }
+    return row;
+  }
+}

package/src/commands/directory/Publish.ts

@@ -0,0 +1,179 @@
+import chalk from 'chalk';
+import {command, flag, help, namespace, param} from 'oo-cli';
+import {terminal} from 'terminal-kit';
+import {AppContext} from '../../lib/AppContext';
+import {die} from '../../lib/die';
+import {formatVersionState} from '../../lib/formatVersionState';
+import {handleInterrupt} from '../../lib/handleInterrupt';
+import {TerminalSpinner} from '../../lib/TerminalSpinner';
+import {Rivendell} from '../../lib/Rivendell';
+import {formatError} from '../../lib/formatError';
+import AppVersionState = Rivendell.AppVersionState;
+import {applicableShards} from '../../lib/Shards';
+import { AppManifest } from '@zaiusinc/app-sdk';
+import { prerelease, rcompare } from 'semver';
+import { UnpublishCommand } from './Unpublish';
+import { TerminalConfirm } from '../../lib/TerminalConfirm';
+
+const STOPPED_STATES = [AppVersionState.START_FAILED, AppVersionState.STOPPED, AppVersionState.STOP_FAILED];
+const UNPUBLISHABLE_STATES = [AppVersionState.RUNNING, AppVersionState.START_FAILED, AppVersionState.STOP_FAILED];
+const PUBLISHABLE_STATES = [
+  AppVersionState.NEW,
+  AppVersionState.PUBLISHED,
+  AppVersionState.START_FAILED,
+  AppVersionState.STOPPED
+];
+
+@namespace('directory')
+export class PublishCommand {
+  @flag('no-progress')
+  public noProgress!: boolean;
+
+  @param
+  @help('The App ID and version (e.g. my_app@1.0.0)')
+  public appVersion!: string;
+
+  @command
+  @help('Publish (make available) a specific app version that has been reviewed and approved')
+  public async publish() {
+    handleInterrupt();
+
+    if (!/[\w-]+@\d+\.\d+\.\d+(?:-\w+\.\d+)?/.test(this.appVersion)) {
+      return die('appVersion is required in the format of app@1.0.0');
+    }
+
+    const [appId, version] = this.appVersion.split('@');
+    console.log(chalk.gray(`Publishing ${this.appVersion} to the directory...`));
+
+    try {
+      const appVersion = await Rivendell.fetchAppVersion({appId, version}, 'us');
+
+      if (!PUBLISHABLE_STATES.includes(appVersion.state as AppVersionState)) {
+        throw new Error(`AppVersion must be in a publishable state. ` +
+                        `Currently: ${formatVersionState(appVersion.state as AppVersionState)}`);
+      }
+
+      const manifest = JSON.parse(appVersion.manifestJson) as AppManifest;
+      const shards = await applicableShards('', manifest);
+      const errors: string[] = [];
+
+      for (const shard of shards) {
+        try {
+          await Rivendell.publish(appId, version, shard);
+          console.log(chalk.green(`Success. ${this.appVersion} is being published to ${shard}.`));
+          const context = {appId, version};
+          await this.watchForPublishCompletion(context, await this.isStopped(context, shard), shard);
+          // since we are handling the interrupt, disable the handler so we can exit
+          terminal.removeAllListeners('key');
+        } catch (error) {
+          errors.push(`${formatError(error)} (${shard})`);
+        }
+      }
+      if (errors.length) {
+        console.error(chalk.red(errors.join('\n')));
+      }
+
+      const pre = prerelease(version);
+      if (pre && pre[0] !== 'dev') {
+        await this.checkOrphanedDeploys(appId, shards);
+      }
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+
+  private async checkOrphanedDeploys(appId: string, currentShards: string[]) {
+    const criteria: Rivendell.AppVersionSearchCriteria = {
+      appId,
+      states: UNPUBLISHABLE_STATES,
+    };
+    const versions: Rivendell.AppVersion[] = await Rivendell.searchAppVersions(criteria, 'us');
+
+    if (versions.length) {
+      versions.sort((x, y) => {
+        return rcompare(x.id.version, y.id.version);
+      });
+
+      const undeployVersions: {[key: string]: Rivendell.AppVersion[]} = {};
+      for (const version of versions) {
+        const appVersion = await Rivendell.fetchAppVersion({appId, version: version.id.version}, 'us');
+        const shards = await applicableShards('', JSON.parse(appVersion.manifestJson) as AppManifest);
+        const check = shards.filter((x: string) => !currentShards.includes(x));
+        for (const s of check) {
+            undeployVersions[s] = await Rivendell.searchAppVersions(criteria, s);
+        }
+      }
+
+      if (Object.keys(undeployVersions).length) {
+        console.log(`You are no longer targeting the availability: ${Object.keys(undeployVersions)}, ` +
+          `do you want to unpublish the following apps:`);
+        console.log(Object.entries(undeployVersions)
+          .map((x) => x[1].map((y) => `* ${y.id.appId}@${y.id.version} in ${x[0]}`).join('\n')).join('\n'));
+        if (await TerminalConfirm.ask(chalk.red('Do you want to unpublish the listed AppVersions now?'))) {
+          for (const [shard, toUndeploy] of Object.entries(undeployVersions)) {
+            for (const version of toUndeploy) {
+              const unpublish = new UnpublishCommand();
+              unpublish.appVersion = `${version.id.appId}@${version.id.version}`;
+              unpublish.availability = shard;
+              await unpublish.unpublish();
+            }
+          }
+        }
+      }
+    }
+  }
+
+  private async isStopped(context: AppContext, shard: string) {
+    const appVersion = await Rivendell.fetchAppVersion(context, shard);
+    return STOPPED_STATES.includes(appVersion.state as AppVersionState);
+  }
+
+  private watchForPublishCompletion(context: AppContext, wasStopped: boolean, shard: string) {
+    console.log(chalk.gray(`Watching for publish (${shard}) to complete... CTRL+C to stop checking.`));
+    return new Promise((resolve, reject) => {
+      const spinner = this.noProgress ? null : new TerminalSpinner().start('');
+      let attempts = 0;
+      let ignoreStopped = wasStopped;
+      const checkStatus = () => {
+        attempts++;
+        Rivendell.fetchAppVersion(context, shard)
+          .then((appVersion) => {
+            const state = appVersion.state as AppVersionState;
+            if (ignoreStopped && !STOPPED_STATES.includes(state)) {
+              ignoreStopped = false;
+            }
+            if (state === AppVersionState.RUNNING || (!ignoreStopped && STOPPED_STATES.includes(state))) {
+              if (spinner) {
+                spinner.stop();
+              }
+              clearInterval(interval);
+              if (state === AppVersionState.RUNNING) {
+                console.log(chalk.green(`${context.appId}@${context.version} has been published to ${shard}.`));
+              } else {
+                die(`Publish to ${shard} failed. ${context.appId}@${context.version} ` +
+                    `in ${formatVersionState(state)} state.`);
+              }
+              resolve();
+            } else {
+              if (attempts > 300) {
+                die('Timed out waiting for completion');
+              }
+              if (spinner) {
+                spinner.update(`Status: ${formatVersionState(state)}`);
+              }
+            }
+          })
+          .catch((e) => {
+            clearInterval(interval);
+            if (spinner) {
+              spinner.stop();
+            }
+            reject(e);
+          });
+      };
+
+      const interval = setInterval(checkStatus, 2000);
+      checkStatus();
+    });
+  }
+}