@optimizely/ocp-cli 1.0.0-beta.2

package/src/lib/Moria.ts

@@ -0,0 +1,66 @@
+import {MoriaApi} from './MoriaApi';
+import { Rivendell } from './Rivendell';
+
+export namespace Moria {
+
+  export interface LogEntryContext {
+    appId?: string;
+    appVersion?: string;
+    trackerId?: string;
+    installId?: string;
+    entryPoint?: string;
+    requestId?: string;
+    jobId?: string;
+    buildId?: string;
+  }
+
+  export interface LoggingSearchCriteria {
+    context: LogEntryContext;
+    start?: number;
+    end?: number;
+    audience?: Audience;
+    level?: LogLevel;
+    pageSize?: number;
+    cursor?: string;
+    terms?: string[];
+  }
+
+  export interface LoggingSearchResult {
+    cursor: string;
+    entries: LogEntry[];
+  }
+
+  export interface LogEntry {
+    id: string;
+    level: LogLevel;
+    time: number;
+    message: string;
+    context: LogEntryContext;
+    audience: Audience;
+  }
+
+  export enum Audience {
+    USER = 'USER',
+    DEVELOPER = 'DEVELOPER',
+    ZAIUS = 'ZAIUS'
+  }
+
+  export enum LogLevel {
+    INFO = 'INFO',
+    DEBUG = 'DEBUG',
+    WARN = 'WARN',
+    ERROR = 'ERROR'
+  }
+
+  /**
+   * Search for LogEntries using the supplied criteria.
+   * @param criteria
+   */
+  export async function searchLogging(
+    criteria: LoggingSearchCriteria,
+    shard: Rivendell.Shard
+  ): Promise<LoggingSearchResult> {
+    const response = await MoriaApi.post<LoggingSearchResult>(shard, 'logging/search', criteria);
+    return response.body;
+  }
+}

package/src/lib/MoriaApi.ts

@@ -0,0 +1,86 @@
+import fetch, {RequestInit, Response} from 'node-fetch';
+import {Rivendell} from './Rivendell';
+
+export type Method = 'POST' | 'PUT' | 'PATCH' | 'GET' | 'DELETE';
+
+/**
+ * Low level http handler for interacting with the Moria api.
+ */
+export namespace MoriaApi {
+
+  interface ApiResponse<T = any> {
+    response: Response;
+    body: T;
+  }
+
+  export class ApiError extends Error {
+    constructor(message: string, public responseText: string, public response?: Response) {
+      super(message);
+    }
+  }
+
+  export async function get<T>(shard: Rivendell.Shard, uri: string): Promise<ApiResponse<T>> {
+    return request(shard, 'GET', uri);
+  }
+
+  export async function post<T>(shard: Rivendell.Shard, uri: string, body: any): Promise<ApiResponse<T>> {
+    return request(shard, 'POST', uri, body);
+  }
+
+  export async function put<T>(shard: Rivendell.Shard, uri: string, body: any): Promise<ApiResponse<T>> {
+    return request(shard, 'PUT', uri, body);
+  }
+
+  export async function request<T>(
+    shard: Rivendell.Shard,
+    method: Method,
+    uri: string,
+    body?: any
+  ): Promise<ApiResponse<T>> {
+    const url = `${shard.url}/${uri}`;
+    const requestPayload: RequestInit = { method };
+
+    requestPayload.headers = {
+      'Authorization': `Bearer ${await Rivendell.jwt(shard.id)}`
+    };
+    if (body && method !== 'GET') {
+      // @ts-ignore
+      requestPayload.headers['content-type'] = 'application/json';
+      requestPayload.body = JSON.stringify(body);
+    }
+
+    const response = await fetch(url, requestPayload);
+    const responseText = await response.text();
+
+    if (response.status < 200 || response.status >= 300) {
+      const errorMsg = `Received a ${response.status} from OCP: ${getErrorMessage(response.status)}`;
+      throw new ApiError(errorMsg, responseText, response);
+    }
+
+    return {
+      response,
+      body: responseText ? JSON.parse(responseText) : ''
+    };
+  }
+
+  function getErrorMessage(code: number): string {
+    switch (code) {
+      case 400:
+        return 'Bad request.';
+      case 403:
+        return 'Access denied.';
+      case 404:
+        return 'Not found.';
+      case 500:
+        return 'Internal service error.';
+      case 502:
+        return 'Bad gateway';
+      case 503:
+        return 'Service unavailable. Please try again.';
+      case 504:
+        return 'Request timed out. Please try again.';
+      default:
+        return 'Unhandled error.';
+    }
+  }
+}

package/src/lib/Rivendell.ts

@@ -0,0 +1,572 @@
+import {RivendellApi} from './RivendellApi';
+import {AppContext} from './AppContext';
+import {DotenvParseOutput} from 'dotenv';
+
+export namespace Rivendell {
+
+  export enum AppVersionState {
+    NEW = 'NEW',
+    PUBLISHED = 'PUBLISHED',
+    BUILD_FAILED = 'BUILD_FAILED',
+    STARTING = 'STARTING',
+    START_FAILED = 'START_FAILED',
+    RUNNING = 'RUNNING',
+    UPGRADING_RUNTIME = 'UPGRADING_RUNTIME',
+    STOPPING = 'STOPPING',
+    STOP_FAILED = 'STOP_FAILED',
+    STOPPED = 'STOPPED'
+  }
+
+  export enum ReviewStatus {
+    NOT_STARTED  = 'NOT_STARTED',
+    IN_REVIEW = 'IN_REVIEW',
+    APPROVED   = 'APPROVED',
+    NOT_REQUIRED = 'NOT_REQUIRED'
+  }
+
+  export enum BuildState {
+    NEW = 'NEW',
+    QUEUED = 'QUEUED',
+    RUNNING = 'RUNNING',
+    FINISHED = 'FINISHED'
+  }
+
+  export enum BuildMode {
+    VALIDATE = 'VALIDATE',
+    PUBLISH = 'PUBLISH'
+  }
+
+  export enum BuildStatus {
+    SUCCESS = 'SUCCESS',
+    FAILURE = 'FAILURE',
+    ERROR = 'ERROR'
+  }
+
+  export enum DeploymentStage {
+    TEST = 'TEST',
+    PRODUCTION = 'PRODUCTION'
+  }
+
+  export enum JobStatus {
+    PENDING = 'PENDING',
+    SCHEDULED = 'SCHEDULED',
+    RUNNING = 'RUNNING',
+    COMPLETE = 'COMPLETE',
+    ERROR = 'ERROR',
+    TERMINATED = 'TERMINATED'
+  }
+
+  export enum JobTriggerType {
+    IMMEDIATE = 'IMMEDIATE',
+    RECURRING = 'RECURRING'
+  }
+
+  export interface AppVersionId {
+    appId: string;
+    version: string;
+  }
+
+  export interface Build {
+    id: number;
+    appVersionId: AppVersionId;
+    mode: BuildMode;
+    state: BuildState;
+    status?: BuildStatus;
+    errors?: string[];
+    queuedAt?: string;
+    runningAt?: string;
+    finishedAt?: string;
+    dependencySet?: string;
+  }
+
+  export interface App {
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+  }
+
+  export interface AppVersion {
+    id: AppVersionId;
+    manifestJson: string;
+    packageUrl: string;
+    state: string;
+    reviewStatus?: string;
+    stage: string;
+    image: string;
+    createdAt: string;
+    updatedAt: string;
+  }
+
+  export interface AppInstallation {
+    id: number;
+    appId: string;
+    version: string;
+    accountId: number;
+    trackerId: string;
+    createdAt: string;
+    updatedAt: string;
+  }
+
+  export interface Job {
+    id: string;
+    accountId: number;
+    trackerId: string;
+    status: JobStatus;
+    definition: JobDefinition;
+    errors: string;
+    triggeredAt: string;
+    scheduledAt: string;
+    startedAt: string;
+    completedAt: string;
+    terminatedAt: string;
+    createdAt: string;
+    updatedAt: string;
+  }
+
+  export interface JobRuntimeStatus {
+    status: string;
+  }
+
+  export interface JobDefinition {
+    id: string;
+    appId: string;
+    version: string;
+    function: string;
+    parameters: string;
+    trigger: JobTriggerType;
+  }
+
+  export interface Webhook {
+    id: string;
+    url: string;
+    attributes: WebhookAttributes;
+    createdAt: string;
+    updatedAt?: string;
+    deletedAt?: string;
+  }
+
+  export interface WebhookAttributes {
+    appId: string;
+    appVersion: string;
+    appInstallId?: number;
+    taskName: string;
+    internal: boolean;
+    enabled: boolean;
+  }
+
+  export interface AppVersionSearchCriteria {
+    appId?: string;
+    version?: string;
+    appName?: string;
+    states?: AppVersionState[];
+    reviewStatuses?: ReviewStatus[];
+    stages?: DeploymentStage[];
+    categories?: Set<string>;
+    sorts?: Sort[];
+  }
+
+  export interface AppInstallationSearchCriteria {
+    appId?: string;
+    version?: string;
+    trackerIds?: string[];
+    sorts?: Sort[];
+  }
+
+  export interface WebhookSearchCriteria {
+    appId?: string;
+    appInstallId?: number;
+    includeInternal?: boolean;
+    includeDisabled?: boolean;
+  }
+
+  export interface JobSearchCriteria {
+    appId: string;
+    versions?: string[];
+    trackerIds?: string[];
+    states?: JobStatus[];
+    functions?: string[];
+    minDurationMillis?: number;
+    sort?: Sort[];
+    limit?: number;
+    start?: number;
+    end?: number;
+  }
+
+  export interface AppReview {
+    url: string;
+  }
+
+  export enum SortDirection {
+    ASC = 'ASC',
+    DESC = 'DESC'
+  }
+
+  export interface Sort {
+    field: string;
+    direction?: SortDirection;
+  }
+
+  export enum Audience {
+    USER = 'USER',
+    DEVELOPER = 'DEVELOPER',
+    ZAIUS = 'ZAIUS'
+  }
+
+  export interface AwsCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken: string;
+    expiration: string;
+  }
+
+  export interface Account {
+    id: number;
+    trackerId: string;
+    name: string;
+  }
+
+  export interface DeveloperApp {
+    id: string;
+  }
+
+  export interface Developer {
+    id: string;
+    email: string;
+    role: string;
+    vendor: string;
+    personal_apps: DeveloperApp[];
+    vendor_apps: DeveloperApp[];
+  }
+
+  export interface Shard {
+    id: string;
+    description: string;
+    url: string;
+    live: boolean;
+  }
+
+  export interface JwtResponse {
+    jwt: string;
+  }
+
+  export interface JwtHeader {
+    kid: string;
+    typ: string;
+    alg: string;
+  }
+
+  export interface JwtPayload {
+    aud: string;
+    exp: number;
+    iss: string;
+    sub: string;
+  }
+
+  export interface Jwt {
+    token: string;
+    header: JwtHeader;
+    payload: JwtPayload;
+  }
+
+  function path(shard: string, endpoint: string) {
+    return `${shard}/${endpoint}`.replace(/^\//, '');
+  }
+
+  export async function searchAccounts(term: string, shard: string): Promise<Account[]> {
+    const response = await RivendellApi.get<Account[]>(
+      path(shard, `accounts/search?term=${encodeURIComponent(term)}`));
+    return response.body;
+  }
+
+  export async function whoami(): Promise<Developer> {
+    const response = await RivendellApi.get<Developer>('developers/me');
+    return response.body;
+  }
+
+  /**
+   * Register a new App.
+   * @param appId
+   * @param name
+   */
+  export async function registerApp(appId: string, name: string, personalApp: boolean, shard: string): Promise<App> {
+    const response = await RivendellApi.post<App>(path(shard, 'apps'), {appId, name, personalApp});
+    return response.body;
+  }
+
+  /**
+   * Fetch an App by identifier.
+   * @param appId
+   */
+  export async function fetchApp(appId: string, shard = ''): Promise<App> {
+    const response = await RivendellApi.get<App>(path(shard, `apps/${appId}`));
+    return response.body;
+  }
+
+  /**
+   * Get app version review url.
+   * @param appId
+   */
+  export async function getReviewUrl(appVersion: string): Promise<AppReview> {
+    const response = await RivendellApi.get<AppReview>(`reviews/${appVersion}`);
+    return response.body;
+  }
+
+  /**
+   * Search for AppVersions using the supplied criteria.
+   * @param criteria
+   */
+  export async function searchAppVersions(criteria: AppVersionSearchCriteria, shard: string): Promise<AppVersion[]> {
+    const response = await RivendellApi.post<AppVersion[]>(path(shard, 'versions/search'), criteria);
+    return response.body;
+  }
+
+  /**
+   * Fetch an AppVersion by identifier.
+   * @param appContext
+   */
+  export async function fetchAppVersion(appContext: AppContext, shard: string): Promise<AppVersion> {
+    const response = await RivendellApi.get<AppVersion>(
+      path(shard, `versions/${appContext.appId}@${appContext.version}`));
+    return response.body;
+  }
+
+  /**
+   * Register a new app version.
+   */
+  export async function registerAppVersion(
+    appId: string,
+    version: string,
+    packageUrl: string,
+    appEnvValues: DotenvParseOutput,
+    usePreviousAppEnvValues: boolean,
+    shard: string
+  ): Promise<AppVersion> {
+    const response = await RivendellApi.post<AppVersion>(
+      path(shard, 'versions'), {appId, version, packageUrl, appEnvValues, usePreviousAppEnvValues});
+    return response.body;
+  }
+
+  /**
+   * Register a new app version.
+   */
+  export async function updateAppVersion(
+    appId: string,
+    version: string,
+    packageUrl: string,
+    appEnvValues: DotenvParseOutput,
+    usePreviousAppEnvValues: boolean,
+    shard: string
+  ): Promise<AppVersion> {
+    const response = await RivendellApi.put<AppVersion>(
+      path(shard, `versions/${appId}@${version}`), {packageUrl, appEnvValues, usePreviousAppEnvValues});
+    return response.body;
+  }
+
+  /**
+   * Review an app version.
+   */
+  export async function reviewAppVersion(
+    appId: string,
+    version: string
+  ): Promise<void> {
+    const appVersionId = `${appId}@${version}`;
+    await RivendellApi.post('reviews', appVersionId);
+  }
+  /**
+   * Search for AppVersions using the supplied criteria.
+   * @param criteria
+   */
+  export async function searchAppInstallations(
+    criteria: AppInstallationSearchCriteria,
+    shard: string
+  ): Promise<AppInstallation[]> {
+    const response = await RivendellApi.post<AppInstallation[]>(path(shard, 'installations/search'), criteria);
+    return response.body;
+  }
+
+  /**
+   * Search for Webhooks using the supplied criteria.
+   * @param criteria
+   */
+  export async function searchWebhooks(criteria: WebhookSearchCriteria, shard: string): Promise<Webhook[]> {
+    const response = await RivendellApi.post<Webhook[]>(path(shard, 'webhooks/search'), criteria);
+    return response.body;
+  }
+
+  /**
+   * Loads a single AppInstallation.
+   * @param appId
+   * @param trackerId
+   */
+  export async function fetchAppInstallation(appId: string, trackerId: string, shard = ''): Promise<AppInstallation> {
+    const response = await searchAppInstallations({appId, trackerIds: [trackerId]}, shard);
+    if (response.length !== 1) {
+      throw new Error(`Installation of ${appId} not found for ${trackerId}`);
+    }
+
+    return response[0];
+  }
+
+  /**
+   * Trigger an installation.
+   */
+  export async function install(
+    appId: string,
+    version: string,
+    trackerId: string,
+    shard: string)
+  : Promise<AppInstallation> {
+    const response = await RivendellApi.post<AppInstallation>(
+      path(shard, 'installations'), {appId, version, trackerId});
+    return response.body;
+  }
+
+  /**
+   * Trigger an uninstall.
+   */
+  export async function uninstall(appInstallationId: number, shard: string): Promise<void> {
+    await RivendellApi.request('DELETE', path(shard, `installations/${appInstallationId}`));
+  }
+
+  /**
+   * Request an upgrade.
+   */
+  export async function upgrade(
+    appInstallationId: number,
+    appId: string,
+    version: string,
+    shard: string
+  ): Promise<void> {
+    await RivendellApi.put(path(shard, `installations/${appInstallationId}`), {appId, version});
+  }
+
+  /**
+   * Trigger a publish.
+   */
+  export async function publish(appId: string, version: string, shard: string): Promise<void> {
+    await RivendellApi.request('PATCH', path(shard, `versions/${appId}@${version}`), {state: AppVersionState.RUNNING});
+  }
+
+  /**
+   * Trigger a unpublish.
+   */
+  export async function unpublish(appId: string, version: string, shard: string): Promise<void> {
+    await RivendellApi.request('PATCH', path(shard, `versions/${appId}@${version}`), {state: AppVersionState.STOPPED});
+  }
+
+  /**
+   * Fetch a build by id.
+   */
+  export async function fetchBuild(id: number): Promise<Build> {
+    const response = await RivendellApi.get<Build>(`builds/${id}`);
+    return response.body;
+  }
+
+  /**
+   * Trigger a build.
+   */
+  export async function build(appId: string, version: string): Promise<Build> {
+    const response = await RivendellApi.post<Build>('builds', {appId, version});
+    return response.body;
+  }
+
+  /**
+   * Trigger a verification.
+   */
+  export async function verify(appId: string, version: string): Promise<Build> {
+    const response = await RivendellApi.post<Build>('verifications', {appId, version});
+    return response.body;
+  }
+
+  /**
+   * Fetch temp credentials to upload to s3.
+   */
+  export async function uploadCredentials(
+    vendor: string,
+    appId: string,
+    version: string,
+    checksum: string
+  ): Promise<AwsCredentials> {
+    const response = await RivendellApi.post<AwsCredentials>('tokens', {vendor, appId, version, checksum});
+    return response.body;
+  }
+
+  /**
+   * List shards.
+   */
+  export async function shards(): Promise<Shard[]> {
+    const response = await RivendellApi.get<Shard[]>('shards');
+    const me = await Rivendell.whoami();
+    return response.body.filter((s) => me.role === 'administrator' || s.live);
+  }
+
+  /**
+   * Search Jobs.
+   */
+  export async function searchJobs(criteria: JobSearchCriteria, shard: string): Promise<Job[]> {
+    const response = await RivendellApi.post<Job[]>(path(shard, 'jobs/search'), criteria);
+    return response.body;
+  }
+
+  /**
+   * Terminate Jobs
+   */
+  export async function terminateJob(jobId: string, shard: string): Promise<void> {
+    await RivendellApi.delete_(path(shard, `jobs/${jobId}`));
+  }
+
+  /**
+   * Trigger a Job
+   */
+  export async function triggerJob(
+    appId: string,
+    jobName: string,
+    trackerId: string,
+    parameters: string,
+    shard: string
+  ): Promise<Job> {
+    const body = {appId, jobName, trackerId, parameters};
+    const response = await RivendellApi.post<Job>(path(shard, 'jobs'), body);
+    return response.body;
+  }
+
+  /**
+   * Fetch a Job
+   */
+  export async function fetchJob(jobId: string, shard: string): Promise<Job> {
+    const response = await RivendellApi.get<Job>(path(shard, `jobs/${jobId}`));
+    return response.body;
+  }
+
+  /**
+   * Fetch a jobs runtimeStatus
+   */
+  export async function fetchJobRuntimeStatus(jobId: string, shard: string): Promise<JobRuntimeStatus> {
+    const response = await RivendellApi.get<JobRuntimeStatus>(path(shard, `jobs/${jobId}/runtimeStatus`));
+    return response.body;
+  }
+
+  /**
+   * Get Moria JWT for this developer.
+   */
+  let cachedJwt: Jwt;
+  export async function jwt(shard: string): Promise<string> {
+    const now = new Date();
+    if (!cachedJwt || cachedJwt.payload.exp * 1000 - now.getTime() <= 60) {
+      const response = await RivendellApi.get<JwtResponse>(path(shard, 'tokens/jwt'));
+      cachedJwt = parseJwt(response.body.jwt);
+    }
+
+    return cachedJwt.token;
+  }
+
+  function parseJwt(token: string): Jwt {
+    const parts = token.split('.');
+    return {
+      token,
+      header: JSON.parse(Buffer.from(parts[0], 'base64').toString()),
+      payload: JSON.parse(Buffer.from(parts[1], 'base64').toString())
+    };
+  }
+}