@revopush/code-push-cli 0.0.1

package/script/acquisition-sdk.ts

@@ -0,0 +1,273 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { UpdateCheckResponse, UpdateCheckRequest, DeploymentStatusReport, DownloadReport } from "../script/types/rest-definitions";
+
+export module Http {
+  export const enum Verb {
+    GET,
+    HEAD,
+    POST,
+    PUT,
+    DELETE,
+    TRACE,
+    OPTIONS,
+    CONNECT,
+    PATCH,
+  }
+
+  export interface Response {
+    statusCode: number;
+    body?: string;
+  }
+
+  export interface Requester {
+    request(verb: Verb, url: string, callback: Callback<Response>): void;
+    request(verb: Verb, url: string, requestBody: string, callback: Callback<Response>): void;
+  }
+}
+
+// All fields are non-nullable, except when retrieving the currently running package on the first run of the app,
+// in which case only the appVersion is compulsory
+export interface Package {
+  deploymentKey: string;
+  description: string;
+  label: string;
+  appVersion: string;
+  isMandatory: boolean;
+  packageHash: string;
+  packageSize: number;
+}
+
+export interface RemotePackage extends Package {
+  downloadUrl: string;
+}
+
+export interface NativeUpdateNotification {
+  updateAppVersion: boolean; // Always true
+  appVersion: string;
+}
+
+export interface LocalPackage extends Package {
+  localPath: string;
+}
+
+export interface Callback<T> {
+  (error: Error, parameter: T): void;
+}
+
+export interface Configuration {
+  appVersion: string;
+  clientUniqueId: string;
+  deploymentKey: string;
+  serverUrl: string;
+  ignoreAppVersion?: boolean;
+}
+
+export class AcquisitionStatus {
+  public static DeploymentSucceeded = "DeploymentSucceeded";
+  public static DeploymentFailed = "DeploymentFailed";
+}
+
+export class AcquisitionManager {
+  private _appVersion: string;
+  private _clientUniqueId: string;
+  private _deploymentKey: string;
+  private _httpRequester: Http.Requester;
+  private _ignoreAppVersion: boolean;
+  private _serverUrl: string;
+
+  constructor(httpRequester: Http.Requester, configuration: Configuration) {
+    this._httpRequester = httpRequester;
+
+    this._serverUrl = configuration.serverUrl;
+    if (this._serverUrl.slice(-1) !== "/") {
+      this._serverUrl += "/";
+    }
+
+    this._appVersion = configuration.appVersion;
+    this._clientUniqueId = configuration.clientUniqueId;
+    this._deploymentKey = configuration.deploymentKey;
+    this._ignoreAppVersion = configuration.ignoreAppVersion;
+  }
+
+  public queryUpdateWithCurrentPackage(currentPackage: Package, callback?: Callback<RemotePackage | NativeUpdateNotification>): void {
+    if (!currentPackage || !currentPackage.appVersion) {
+      throw new Error("Calling common acquisition SDK with incorrect package"); // Unexpected; indicates error in our implementation
+    }
+
+    const updateRequest: UpdateCheckRequest = {
+      deploymentKey: this._deploymentKey,
+      appVersion: currentPackage.appVersion,
+      packageHash: currentPackage.packageHash,
+      isCompanion: this._ignoreAppVersion,
+      label: currentPackage.label,
+      clientUniqueId: this._clientUniqueId,
+    };
+
+    const requestUrl: string = this._serverUrl + "updateCheck?" + queryStringify(updateRequest);
+
+    this._httpRequester.request(Http.Verb.GET, requestUrl, (error: Error, response: Http.Response) => {
+      if (error) {
+        callback(error, /*remotePackage=*/ null);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        callback(new Error(response.statusCode + ": " + response.body), /*remotePackage=*/ null);
+        return;
+      }
+
+      let updateInfo: UpdateCheckResponse;
+
+      try {
+        const responseObject = JSON.parse(response.body);
+        updateInfo = responseObject.updateInfo;
+      } catch (error) {
+        callback(error, /*remotePackage=*/ null);
+        return;
+      }
+
+      if (!updateInfo) {
+        callback(error, /*remotePackage=*/ null);
+        return;
+      } else if (updateInfo.updateAppVersion) {
+        callback(/*error=*/ null, {
+          updateAppVersion: true,
+          appVersion: updateInfo.appVersion,
+        });
+        return;
+      } else if (!updateInfo.isAvailable) {
+        callback(/*error=*/ null, /*remotePackage=*/ null);
+        return;
+      }
+
+      const remotePackage: RemotePackage = {
+        deploymentKey: this._deploymentKey,
+        description: updateInfo.description,
+        label: updateInfo.label,
+        appVersion: updateInfo.appVersion,
+        isMandatory: updateInfo.isMandatory,
+        packageHash: updateInfo.packageHash,
+        packageSize: updateInfo.packageSize,
+        downloadUrl: updateInfo.downloadURL,
+      };
+
+      callback(/*error=*/ null, remotePackage);
+    });
+  }
+
+  public reportStatusDeploy(
+    deployedPackage?: Package,
+    status?: string,
+    previousLabelOrAppVersion?: string,
+    previousDeploymentKey?: string,
+    callback?: Callback<void>
+  ): void {
+    const url: string = this._serverUrl + "reportStatus/deploy";
+    const body: DeploymentStatusReport = {
+      appVersion: this._appVersion,
+      deploymentKey: this._deploymentKey,
+    };
+
+    if (this._clientUniqueId) {
+      body.clientUniqueId = this._clientUniqueId;
+    }
+
+    if (deployedPackage) {
+      body.label = deployedPackage.label;
+      body.appVersion = deployedPackage.appVersion;
+
+      switch (status) {
+        case AcquisitionStatus.DeploymentSucceeded:
+        case AcquisitionStatus.DeploymentFailed:
+          body.status = status;
+          break;
+
+        default:
+          if (callback) {
+            if (!status) {
+              callback(new Error("Missing status argument."), /*not used*/ null);
+            } else {
+              callback(new Error('Unrecognized status "' + status + '".'), /*not used*/ null);
+            }
+          }
+          return;
+      }
+    }
+
+    if (previousLabelOrAppVersion) {
+      body.previousLabelOrAppVersion = previousLabelOrAppVersion;
+    }
+
+    if (previousDeploymentKey) {
+      body.previousDeploymentKey = previousDeploymentKey;
+    }
+
+    callback = typeof arguments[arguments.length - 1] === "function" && arguments[arguments.length - 1];
+
+    this._httpRequester.request(Http.Verb.POST, url, JSON.stringify(body), (error: Error, response: Http.Response): void => {
+      if (callback) {
+        if (error) {
+          callback(error, /*not used*/ null);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          callback(new Error(response.statusCode + ": " + response.body), /*not used*/ null);
+          return;
+        }
+
+        callback(/*error*/ null, /*not used*/ null);
+      }
+    });
+  }
+
+  public reportStatusDownload(downloadedPackage: Package, callback?: Callback<void>): void {
+    const url: string = this._serverUrl + "reportStatus/download";
+    const body: DownloadReport = {
+      clientUniqueId: this._clientUniqueId,
+      deploymentKey: this._deploymentKey,
+      label: downloadedPackage.label,
+    };
+
+    this._httpRequester.request(Http.Verb.POST, url, JSON.stringify(body), (error: Error, response: Http.Response): void => {
+      if (callback) {
+        if (error) {
+          callback(error, /*not used*/ null);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          callback(new Error(response.statusCode + ": " + response.body), /*not used*/ null);
+          return;
+        }
+
+        callback(/*error*/ null, /*not used*/ null);
+      }
+    });
+  }
+}
+
+function queryStringify(object: Object): string {
+  let queryString = "";
+  let isFirst: boolean = true;
+
+  for (const property in object) {
+    if (object.hasOwnProperty(property)) {
+      const value: string = (<any>object)[property];
+      if (!isFirst) {
+        queryString += "&";
+      }
+
+      queryString += encodeURIComponent(property) + "=";
+      if (value !== null && typeof value !== "undefined") {
+        queryString += encodeURIComponent(value);
+      }
+
+      isFirst = false;
+    }
+  }
+
+  return queryString;
+}

package/script/cli.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import * as parser from "./command-parser";
+import * as execute from "./command-executor";
+import * as chalk from "chalk";
+
+function run() {
+  const command = parser.createCommand();
+
+  if (!command) {
+    parser.showHelp(/*showRootDescription*/ false);
+    return;
+  }
+
+  execute
+    .execute(command)
+    .catch((error: any): void => {
+      console.error(chalk.red(`[Error]  ${error.message}`));
+      process.exit(1);
+    })
+    .done();
+}
+
+run();