@contentstack/cli-utilities 0.1.1-beta.1

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@contentstack/cli-utilities",
+  "version": "0.1.1-beta.1",
+  "description": "Utilities for contentstack projects",
+  "main": "lib/index.js",
+  "types": "./types/index.d.ts",
+  "scripts": {
+    "prepack": "npm run clean && npm run compile",
+    "clean": "rm -rf ./lib && rm -rf tsconfig.build.tsbuildinfo",
+    "compile": "tsc -b tsconfig.json",
+    "test:report": "tsc -p test && nyc --reporter=lcov --extension .ts mocha --forbid-only \"test/**/*.test.ts\"",
+    "pretest": "tsc -p test",
+    "test": "nyc --extension .ts mocha --forbid-only \"test/**/*.test.ts\"",
+    "posttest": "npm run lint",
+    "lint": "eslint src/**/*.ts",
+    "format": "eslint src/**/*.ts --fix"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "keywords": [
+    "contentstack",
+    "utilities"
+  ],
+  "author": "contentstack",
+  "license": "MIT",
+  "dependencies": {
+    "@contentstack/management": "^1.3.0",
+    "@oclif/core": "^1.8.2",
+    "axios": "^0.27.2",
+    "chalk": "^4.0.0",
+    "conf": "^10.1.2",
+    "debug": "^4.1.1",
+    "inquirer": "^8.0.0",
+    "ora": "^5.4.0",
+    "winston": "^3.7.2"
+  },
+  "devDependencies": {
+    "@oclif/plugin-help": "^5.1.12",
+    "@oclif/test": "^1.2.8",
+    "@types/axios": "^0.14.0",
+    "@types/chai": "^4.2.18",
+    "@types/conf": "^3.0.0",
+    "@types/dot-prop": "^5.0.1",
+    "@types/inquirer": "^7.3.1",
+    "@types/mkdirp": "^1.0.1",
+    "@types/mocha": "^8.2.2",
+    "@types/nock": "^11.1.0",
+    "@types/node": "^14.14.32",
+    "@types/sinon": "^10.0.2",
+    "@types/tar": "^4.0.3",
+    "@types/winston": "^2.4.4",
+    "chai": "^4.3.4",
+    "eslint": "^8.18.0",
+    "eslint-config-oclif": "^3.1.0",
+    "eslint-config-oclif-typescript": "^0.1.0",
+    "globby": "^10.0.2",
+    "mocha": "^9.2.2",
+    "nock": "^13.1.0",
+    "nyc": "^15.1.0",
+    "rimraf": "^2.7.1",
+    "sinon": "^11.1.1",
+    "tmp": "^0.2.1",
+    "ts-node": "^8.10.2",
+    "typescript": "^4.7.4"
+  }
+}

package/src/cli-error.ts

@@ -0,0 +1,15 @@
+export default class CLIError extends Error {
+  suggestions?: string[];
+
+  constructor(message, suggestions?: string[]) {
+    super(message);
+    this.suggestions = suggestions;
+    this.message = message;
+
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+  }
+}

package/src/cli-ux.ts

@@ -0,0 +1,78 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { ux as cliux, Table } from '@oclif/core/lib/cli-ux'
+
+import messageHandler from './message-handler';
+import { PrintOptions, InquirePayload, CliUXPromptOptions } from './interfaces';
+
+/**
+ * CLI Interface
+ */
+class CLIInterface {
+  private loading: boolean;
+
+  constructor() {
+    this.loading = false;
+  }
+
+  get uxTable(): typeof Table.table {
+    return cliux.table
+  }
+
+  init(context) {}
+
+  print(message: string, opts?: PrintOptions): void {
+    if (opts && opts.color) {
+      cliux.log(chalk[opts.color](messageHandler.parse(message)));
+      return;
+    }
+
+    cliux.log(messageHandler.parse(message));
+  }
+
+  success(message: string): void {
+    cliux.log(chalk.green(messageHandler.parse(message)));
+  }
+
+  error(message: string, ...params: any): void {
+    cliux.log(chalk.red(messageHandler.parse(message) + (params && params.length > 0 ? ': ' : '')), ...params);
+  }
+
+  loader(message: string = ''): void {
+    if (!this.loading) {
+      cliux.action.start(messageHandler.parse(message));
+    } else {
+      cliux.action.stop(messageHandler.parse(message));
+    }
+    this.loading = !this.loading;
+  }
+
+  table(
+    data: Record<string, unknown>[],
+    columns: Table.table.Columns<Record<string, unknown>>,
+    options?: Table.table.Options
+  ): void {
+    cliux.table(data, columns, options);
+  }
+
+  async inquire<T>(inquirePayload: InquirePayload): Promise<T> {
+    inquirePayload.message = messageHandler.parse(inquirePayload.message);
+    const result = await inquirer.prompt(inquirePayload as inquirer.QuestionCollection<T>);
+
+    return result[inquirePayload.name] as T;
+  }
+
+  prompt(name: string, options?: CliUXPromptOptions): Promise<any> {
+    return cliux.prompt(name, options)
+  }
+
+  confirm(message?: string): Promise<boolean> {
+    return cliux.confirm(message)
+  }
+
+  progress(options?: any): any {
+    return cliux.progress(options)
+  }
+}
+
+export default new CLIInterface();

package/src/config-handler.ts

@@ -0,0 +1,142 @@
+import Conf from 'conf';
+import { v4 as uuid } from 'uuid';
+import { existsSync, unlinkSync } from 'fs'
+
+const ENC_KEY = 'encryptionKey';
+const ENCRYPT_CONF: boolean = true
+const CONFIG_NAME = 'contentstack_cli';
+const ENC_CONFIG_NAME = 'contentstack_cli_obfuscate';
+
+class Config {
+  private config: Conf;
+
+  constructor() {
+    this.init()
+  }
+
+  init() {
+    return ENCRYPT_CONF === true
+      ? this.getEncryptedConfig()
+      : this.getDecryptedConfig()
+  }
+
+  private fallbackInit(): Conf {
+    return new Conf({ configName: CONFIG_NAME, encryptionKey: ENC_KEY })
+  }
+
+  private getObfuscationKey() {
+    const obfuscationKeyName = 'obfuscation_key'
+    const encConfig = new Conf({ configName: ENC_CONFIG_NAME })
+    let obfuscationKey: any = encConfig.get(obfuscationKeyName)
+
+    if (!obfuscationKey) {
+      encConfig.set(obfuscationKeyName, uuid())
+      obfuscationKey = encConfig.get(obfuscationKeyName)
+    }
+
+    return obfuscationKey
+  }
+
+  private getConfigDataAndUnlinkConfigFile(config: Conf) {
+    let configData
+
+    if (config?.path) {
+      if (existsSync(config.path)) {
+        configData = JSON.parse(JSON.stringify(config?.store || {})) // NOTE convert prototype object to plain object
+        unlinkSync(config.path) // NOTE remove old config file
+      }
+    }
+
+    return configData
+  }
+
+  private getEncryptedConfig(configData?: Record<string, unknown>, skip = false) {
+    const getEncryptedDataElseFallBack = () => {
+      try {
+        // NOTE reading current code base encrypted file if exist
+        const encryptionKey: any = this.getObfuscationKey()
+        this.config = new Conf({ configName: CONFIG_NAME, encryptionKey })
+
+        if (Object.keys(configData || {})?.length) {
+          this.config.set(configData) // NOTE set config data if passed any
+        }
+      } catch (error) {
+        // NOTE reading old code base encrypted file if exist
+        try {
+          const config = this.fallbackInit()
+          const configData = this.getConfigDataAndUnlinkConfigFile(config)
+          this.getEncryptedConfig(configData, true)
+        } catch (error) {
+          // console.trace(error.message)
+        }
+      }
+    }
+
+    try {
+      if (skip === false) {
+        const config = new Conf({ configName: CONFIG_NAME })
+        const configData = this.getConfigDataAndUnlinkConfigFile(config)
+        this.getEncryptedConfig(configData, true)
+      } else {
+        getEncryptedDataElseFallBack()
+      }
+    } catch (error) {
+      // console.trace(error.message)
+      // NOTE reading current code base encrypted file if exist
+      getEncryptedDataElseFallBack()
+    }
+
+    return this.config
+  }
+
+  private getDecryptedConfig(configData?: Record<string, unknown>) {
+    try {
+      this.config = new Conf({ configName: CONFIG_NAME })
+
+      if (Object.keys(configData || {})?.length) {
+        this.config.set(configData) // NOTE set config data if passed any
+      }
+    } catch (error) {
+      // console.trace(error.message)
+
+      try {
+        const encryptionKey: any = this.getObfuscationKey()
+        let config = new Conf({ configName: CONFIG_NAME, encryptionKey })
+        const configData = this.getConfigDataAndUnlinkConfigFile(config)
+        this.getDecryptedConfig(configData) // NOTE NOTE reinitialize the config with old data and new decrypted file
+      } catch (error) {
+        // console.trace(error.message)
+
+        try {
+          const config = this.fallbackInit()
+          const configData = this.getConfigDataAndUnlinkConfigFile(config)
+          this.getDecryptedConfig(configData) // NOTE reinitialize the config with old data and new decrypted file
+        } catch (error) {
+          // console.trace(error.message)
+        }
+      }
+    }
+
+    return this.config
+  }
+
+  get(key): string | any {
+    return this.config.get(key);
+  }
+
+  async set(key, value) {
+    this.config.set(key, value);
+    return this.config;
+  }
+
+  delete(key) {
+    this.config.delete(key);
+    return this.config;
+  }
+
+  clear() {
+    this.config.clear()
+  }
+}
+
+export default new Config();

package/src/flag-deprecation-check.ts

@@ -0,0 +1,41 @@
+import cliux from './cli-ux';
+
+/**
+ * checks the deprecation and prints it
+ * @param {Array} deprecatedFlags flags to be deprecated
+ * @param {String} customMessage [optional] a custom message
+ * @returns flag parser
+ */
+export default function (deprecatedFlags = [], suggestions = [], customMessage?: string) {
+  return (input, command) => {
+    const { context: { flagWarningPrintState = {} } = {} } = command
+    let isCommandHasDeprecationFlag = false;
+    deprecatedFlags.forEach((item) => {
+      if (command.argv.indexOf(item) !== -1) {
+        if (flagWarningPrintState[command.id + item]) {
+          return input
+        }
+        flagWarningPrintState[command.id + item] = true
+        isCommandHasDeprecationFlag = true;
+      }
+    });
+
+    if (isCommandHasDeprecationFlag) {
+      let depreactionMessage = '';
+      if (customMessage) {
+        depreactionMessage = customMessage;
+      } else {
+        depreactionMessage = `WARNING!!! You're using the old (soon to be deprecated) Contentstack CLI flags (${deprecatedFlags.join(
+          ', ',
+        )}).`;
+
+        if (suggestions.length > 0) {
+          depreactionMessage += ` We recommend you to use the updated flags (${suggestions.join(', ')}).`;
+        }
+      }
+      cliux.print(depreactionMessage, { color: 'yellow' });
+    }
+
+    return input;
+  };
+}

package/src/http-client/client.ts

@@ -0,0 +1,369 @@
+import Axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { HttpResponse } from './http-response';
+
+export class HttpClient {
+  /**
+   * The request configuration.
+   */
+  private request: AxiosRequestConfig;
+
+  /**
+   * The request configuration.
+   */
+  private readonly axiosInstance: AxiosInstance;
+
+  /**
+   * The payload format for a JSON or form-url-encoded request.
+   */
+  private bodyFormat: BodyFormat = 'json';
+
+  /**
+   * Createa new pending HTTP request instance.
+   */
+  constructor() {
+    this.request = {};
+    this.axiosInstance = Axios.create();
+
+    // Sets payload format as json by default
+    this.asJson();
+  }
+
+  /**
+   * Create a reusable HttpClient instance.
+   *
+   * @returns {HttpClient}
+   */
+  static create(): HttpClient {
+    return new this();
+  }
+
+  /**
+   * Returns the Axios request config.
+   *
+   * @returns {AxiosRequestConfig}
+   */
+  requestConfig(): AxiosRequestConfig {
+    return this.request;
+  }
+
+  /**
+   * Resets the request config.
+   *
+   * @returns {AxiosRequestConfig}
+   */
+  resetConfig(): HttpClient {
+    this.request = {};
+    return this;
+  }
+
+  /**
+   * Use the given `baseUrl` for all requests.
+   *
+   * @param {String} baseUrl
+   *
+   * @returns {HttpClient}
+   */
+  baseUrl(baseUrl: string): HttpClient {
+    if (typeof baseUrl !== 'string') {
+      throw new Error(`The base URL must be a string. Received "${typeof baseUrl}"`);
+    }
+
+    this.request.baseURL = baseUrl;
+
+    return this;
+  }
+
+  /**
+   * Add request headers.
+   * @returns {HttpClient}
+   */
+  headers(headers: any): HttpClient {
+    this.request.headers = { ...this.request.headers, ...headers };
+
+    return this;
+  }
+
+  /**
+   * Add query parameters to the request.
+   *
+   * @param {Object} queryParams
+   *
+   * @returns {HttpClient}
+   */
+  queryParams(queryParams: object): HttpClient {
+    this.request.params = { ...this.request.params, ...queryParams };
+
+    return this;
+  }
+
+  /**
+   * Add basic authentication via `username` and `password` to the request.
+   *
+   * @param {String} username
+   * @param {String} password
+   *
+   * @returns {HttpClient}
+   */
+  basicAuth(username: string, password: string): HttpClient {
+    this.request.auth = { username, password };
+
+    return this;
+  }
+
+  /**
+   * Add an authorization `token` to the request.
+   *
+   * @param {String} token
+   * @param {String} type
+   *
+   * @returns {HttpClient}
+   */
+  token(token: string, type: string = 'Bearer'): HttpClient {
+    return this.headers({
+      Authorization: `${type} ${token}`.trim(),
+    });
+  }
+
+  /**
+   * Merge your own custom Axios options into the request.
+   *
+   * @param {Object} options
+   *
+   * @returns {HttpClient}
+   */
+  options(options: AxiosRequestConfig = {}): HttpClient {
+    Object.assign(this.request, options);
+
+    return this;
+  }
+
+  /**
+   * Add a request payload.
+   *
+   * @param {*} data
+   *
+   * @returns {HttpClient}
+   */
+  payload(data: any): HttpClient {
+    this.request.data = data;
+
+    return this;
+  }
+
+  /**
+   * Define the request `timeout` in milliseconds.
+   *
+   * @param {Number} timeout
+   *
+   * @returns {HttpClient}
+   */
+  timeout(timeout: number): HttpClient {
+    this.request.timeout = timeout;
+
+    return this;
+  }
+
+  /**
+   * Tell HttpClient to send the request as JSON payload.
+   *
+   * @returns {HttpClient}
+   */
+  asJson(): HttpClient {
+    return this.payloadFormat('json').contentType('application/json');
+  }
+
+  /**
+   * Tell HttpClient to send the request as form parameters,
+   * encoded as URL query parameters.
+   *
+   * @returns {HttpClient}
+   */
+  asFormParams(): HttpClient {
+    return this.payloadFormat('formParams').contentType('application/x-www-form-urlencoded');
+  }
+
+  /**
+   * Set the request payload format.
+   *
+   * @param {String} format
+   *
+   * @returns {HttpClient}
+   */
+  payloadFormat(format: BodyFormat): HttpClient {
+    this.bodyFormat = format;
+
+    return this;
+  }
+
+  /**
+   * Set the `Accept` request header. This indicates what
+   * content type the server should return.
+   *
+   * @param {String} accept
+   *
+   * @returns {HttpClient}
+   */
+  accept(accept: string): HttpClient {
+    return this.headers({ Accept: accept });
+  }
+
+  /**
+   * Set the `Accept` request header to JSON. This indicates
+   * that the server should return JSON data.
+   *
+   * @param {String} accept
+   *
+   * @returns {HttpClient}
+   */
+  acceptJson(): HttpClient {
+    return this.accept('application/json');
+  }
+
+  /**
+   * Set the `Content-Type` request header.
+   *
+   * @param {String} contentType
+   *
+   * @returns {HttpClient}
+   */
+  contentType(contentType: string): HttpClient {
+    return this.headers({ 'Content-Type': contentType });
+  }
+
+  /**
+   * Send an HTTP GET request, optionally with the given `queryParams`.
+   *
+   * @param {String} url
+   * @param {Object} queryParams
+   *
+   * @returns {HttpResponse}
+   *
+   * @throws
+   */
+  async get<R>(url: string, queryParams: object = {}): Promise<HttpResponse<R>> {
+    this.queryParams(queryParams);
+
+    return this.send<R>('GET', url);
+  }
+
+  /**
+   * Send an HTTP POST request, optionally with the given `payload`.
+   *
+   * @param {String} url
+   * @param {Object} payload
+   *
+   * @returns {HttpResponse}
+   *
+   * @throws
+   */
+  async post<R>(url: string, payload?: any): Promise<HttpResponse<R>> {
+    if (payload) {
+      this.payload(payload);
+    }
+
+    return this.send<R>('POST', url);
+  }
+
+  /**
+   * Send an HTTP PUT request, optionally with the given `payload`.
+   *
+   * @param {String} url
+   * @param {Object} payload
+   *
+   * @returns {HttpResponse}
+   *
+   * @throws
+   */
+  async put<R>(url: string, payload?: any): Promise<HttpResponse<R>> {
+    if (payload) {
+      this.payload(payload);
+    }
+
+    return this.send<R>('PUT', url);
+  }
+
+  /**
+   * Send an HTTP PATCH request, optionally with the given `payload`.
+   *
+   * @param {String} url
+   * @param {Object} payload
+   *
+   * @returns {HttpResponse}
+   *
+   * @throws
+   */
+  async patch<R>(url: string, payload?: any): Promise<HttpResponse<R>> {
+    if (payload) {
+      this.payload(payload);
+    }
+
+    return this.send<R>('PATCH', url);
+  }
+
+  /**
+   * Send an HTTP DELETE request, optionally with the given `queryParams`.
+   *
+   * @param {String} url
+   * @param {Object} queryParams
+   *
+   * @returns {HttpResponse}
+   *
+   * @throws
+   */
+  async delete<R>(url: string, queryParams: object = {}): Promise<HttpResponse<R>> {
+    this.queryParams(queryParams);
+
+    return this.send<R>('DELETE', url);
+  }
+
+  /**
+   * Send the HTTP request.
+   *
+   * @param {String} method
+   * @param {String} url
+   *
+   * @returns {HttpResponse}
+   *
+   * @throws
+   */
+  async send<R>(method: HttpMethod, url: string): Promise<HttpResponse<R>> {
+    try {
+      return new HttpResponse<R>(await this.createAndSendRequest(method, url));
+    } catch (error: any) {
+      if (error.response) {
+        return new HttpResponse(error.response);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Create and send the HTTP request.
+   *
+   * @param {String} method
+   * @param {String} url
+   *
+   * @returns {Request}
+   */
+  async createAndSendRequest(method: HttpMethod, url: string): Promise<AxiosResponse> {
+    return await this.axiosInstance({
+      url,
+      method,
+      withCredentials: true,
+      ...this.request,
+      data: this.prepareRequestPayload(),
+    });
+  }
+
+  /**
+   * Returns the request payload depending on the selected request payload format.
+   */
+  prepareRequestPayload(): any {
+    return this.bodyFormat === 'formParams' ? new URLSearchParams(this.request.data).toString() : this.request.data;
+  }
+}
+
+type BodyFormat = 'json' | 'formParams';
+
+type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS';