@contentstack/cli-utilities 0.1.1-beta.1

package/src/http-client/http-response.ts

@@ -0,0 +1,55 @@
+'use strict';
+
+import { AxiosResponse } from 'axios';
+
+export class HttpResponse<ResponseType = any> {
+  /**
+   * The Axios response object.
+   */
+  private readonly response: AxiosResponse;
+
+  /**
+   * Wrap the given Axios `response` into a new response instance.
+   *
+   * @param {AxiosResponse} response
+   */
+  constructor(response: AxiosResponse) {
+    this.response = response;
+  }
+
+  /**
+   * Returns the response status.
+   *
+   * @returns {Number}
+   */
+  get status() {
+    return this.response.status;
+  }
+
+  /**
+   * Returns the response payload. This method is an alias for `response.payload()`.
+   *
+   * @returns {*}
+   */
+  get data() {
+    return this.payload;
+  }
+
+  /**
+   * Returns the response payload.
+   *
+   * @returns {*}
+   */
+  get payload() {
+    return this.response.data;
+  }
+
+  /**
+   * Returns the response headers.
+   *
+   * @returns {Object}
+   */
+  get headers() {
+    return this.response.headers;
+  }
+}

package/src/http-client/index.ts

@@ -0,0 +1,7 @@
+'use strict';
+
+import { HttpClient } from './client';
+
+export default HttpClient;
+export * from './client';
+export * from './http-response';

package/src/index.ts

@@ -0,0 +1,7 @@
+export { default as logger } from './logger';
+export { default as cliux } from './cli-ux';
+export { default as CLIError } from './cli-error';
+export { default as messageHandler } from './message-handler';
+export { default as configHandler } from './config-handler';
+export { default as printFlagDeprecation } from './flag-deprecation-check';
+export * from './http-client';

package/src/interfaces/index.ts

@@ -0,0 +1,61 @@
+import { IPromptOptions } from "@oclif/core/lib/cli-ux";
+
+export interface PrintOptions {
+  color?: string;
+}
+
+export interface InquirePayload {
+  type: string;
+  name: string;
+  message: string;
+  choices?: Array<any>;
+  transformer?: Function;
+}
+
+export interface Region {
+  name: string;
+  cma: string;
+  cda: string;
+}
+
+export interface Token {
+  token: string;
+  apiKey: string;
+}
+
+export interface Organization {
+  uid: string,
+  name: string,
+}
+
+export interface selectedOrganization {
+  orgUid: string,
+  orgName: string,
+}
+
+export interface Stack {
+  name: string,
+  api_key: string,
+}
+
+export interface ContentType {
+  uid: string,
+  title: string,
+}
+
+export interface Environment {
+  name: string,
+  uid: string,
+}
+
+export interface Entry {
+  uid: string,
+  title: string,
+}
+
+export interface Locale {
+  name: string;
+  code: string;
+}
+
+export interface CliUXPromptOptions extends IPromptOptions {}

package/src/logger.ts

@@ -0,0 +1,101 @@
+import winston from 'winston';
+import messageHandler from './message-handler';
+
+class LoggerService {
+  name: string;
+  data: object | null;
+  logger: winston.Logger;
+
+  static dateFormat(): string {
+    return new Date(Date.now()).toUTCString();
+  }
+  constructor(name: string) {
+    this.data = null;
+    this.name = null;
+
+    const logger = winston.createLogger({
+      transports: [
+        // new winston.transports.Console(),
+        new winston.transports.File({
+          filename: `./logs/${name}.log`,
+        }),
+      ],
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.printf((info) => {
+          let stringifiedParam;
+          try {
+            stringifiedParam = JSON.stringify(info.obj);
+          } catch (error) {
+            console.log('warning: failed to log the result');
+          }
+          // parse message
+          info.message = messageHandler.parse(info.message);
+          let message = `${LoggerService.dateFormat()}:${name}:${info.level}:${info.message}`;
+          message = info.obj ? message + `:${stringifiedParam}` : message;
+          message = this.data ? message + `:${JSON.stringify(this.data)}` : message;
+          return message;
+        }),
+      ),
+      // level: (config.get('logger.level') as string) || 'error',
+      level: 'error',
+      silent: true
+      // silent: config.get('logger.enabled') && process.env.CLI_ENV !== 'TEST' ? false : false,
+    });
+    this.logger = logger;
+  }
+
+  init(context) {
+    this.name = (context && context.plugin && context.plugin.name) || 'cli';
+  }
+
+  set loggerName(name: string) {
+    this.name = name;
+  }
+
+  setLogData(data: object): void {
+    this.data = data;
+  }
+
+  async info(message: string, param?: any): Promise<any> {
+    if (param) {
+      this.logger.log('info', message, {
+        obj: param,
+      });
+    } else {
+      this.logger.log('info', message);
+    }
+  }
+
+  async debug(message: string, param?: any): Promise<any> {
+    if (param) {
+      this.logger.log('debug', message, {
+        obj: param,
+      });
+    } else {
+      this.logger.log('debug', message);
+    }
+  }
+
+  async error(message: string, param?: any): Promise<any> {
+    if (param) {
+      this.logger.log('error', message, {
+        obj: param,
+      });
+    } else {
+      this.logger.log('error', message);
+    }
+  }
+
+  async warn(message: string, param?: any): Promise<any> {
+    if (param) {
+      this.logger.log('warn', message, {
+        obj: param,
+      });
+    } else {
+      this.logger.log('warn', message);
+    }
+  }
+}
+
+export default new LoggerService('cli');

package/src/message-handler.ts

@@ -0,0 +1,45 @@
+import fs from 'fs';
+import CLIError from './cli-error';
+
+/**
+ * Message handler
+ */
+class Messages {
+  private messages: object;
+  messageFilePath: any;
+
+  constructor() {
+    this.messages = {};
+  }
+
+  init(context) {
+    if (!context.messageFilePath) {
+      return;
+    }
+    try {
+      this.messages = JSON.parse(fs.readFileSync(context.messageFilePath, 'utf-8'));
+    } catch (error) {
+      // create empty messages object if message file is not exist
+      if (error.code === 'ENOENT') {
+        this.messages = {};
+      } else {
+        throw new CLIError(error.message);
+      }
+    }
+  }
+
+  parse(messageKey: string, ...substitutions: Array<any>): string {
+    const msg = this.messages[messageKey];
+    if (!msg) {
+      return messageKey;
+    }
+    if (substitutions.length > 0) {
+      const callSite = msg.split('%s');
+      callSite.push('');
+      return String.raw({ raw: callSite } as TemplateStringsArray, ...substitutions);
+    }
+    return msg;
+  }
+}
+
+export default new Messages();

package/src/selectors/index.ts

@@ -0,0 +1,381 @@
+import ora from 'ora'
+import { default as config } from '../config-handler';
+import {
+	Token,
+	Organization,
+	selectedOrganization,
+	Stack,
+	ContentType,
+	Environment,
+	Entry,
+	Locale
+} from './interfaces'
+import { shouldNotBeEmpty } from './validations'; 
+
+const inquirer = require('inquirer')
+inquirer.registerPrompt('search-list', require('inquirer-search-list'))
+inquirer.registerPrompt('search-checkbox', require('inquirer-search-checkbox'))
+const {Command} = require('@contentstack/cli-command')
+
+export function chooseOrganization(client: any, displayMessage?: string, region?: string, orgUid?: string): Promise<selectedOrganization> {
+	return new Promise(async (resolve, reject) => {
+		try {
+			const spinner = ora('Loading Organizations').start()
+			let {items: organizations} = await client.organization().fetchAll()
+			spinner.stop()
+			let orgMap: any = {}
+			if (orgUid) {
+				organizations.forEach((org: Organization) => {
+					orgMap[org.uid] = org.name
+				})
+				if (orgMap[orgUid]) {
+					resolve({orgUid: orgUid, orgName: orgMap[orgUid]})
+				} else {
+					return reject(new Error('The given orgUid doesn\'t exist or you might not have access to it.'))
+				}
+			} else {
+				organizations.forEach((org: Organization) => {
+					orgMap[org.name] = org.uid
+				})
+				const orgList = Object.keys(orgMap)
+				let inquirerConfig = {
+					type: 'search-list',
+					name: 'chosenOrganization',
+					message: displayMessage || 'Choose an organization',
+					choices: orgList,
+					loop: false,
+					validate: shouldNotBeEmpty
+				}
+				inquirer.prompt(inquirerConfig).then(({chosenOrganization}: {chosenOrganization: string}) => {
+					resolve({orgUid: orgMap[chosenOrganization], orgName: chosenOrganization})
+				})
+			}
+		} catch (error) {
+			reject(error)
+		}
+	})
+}
+
+export function chooseStack(client: any, organizationId: string, displayMessage?: string, region?: string) : Promise<Stack> {
+	return new Promise(async (resolve, reject) => {
+		try {
+			const spinner = ora('Loading Stacks').start()
+			let {items: stacks} = await client.stack({organization_uid: organizationId}).query({query: {}}).find()
+			spinner.stop()
+			let stackMap: any = {}
+			stacks.forEach((stack: Stack) => {
+				stackMap[stack.name] = stack.api_key
+			})
+			const stackList = Object.keys(stackMap)
+			let inquirerConfig = {
+				type: 'search-list',
+				name: 'chosenStack',
+				choices: stackList,
+				message: displayMessage || 'Choose a stack',
+				loop: false,
+			}
+			inquirer.prompt(inquirerConfig).then(({chosenStack}: {chosenStack: string}) => {
+				resolve({api_key: stackMap[chosenStack], name: chosenStack})
+			})
+		} catch (error) {
+			console.error(error.message)
+		}
+	})
+}
+
+export function chooseContentType(stackApiKey: string, displayMessage?: string, region?: string): Promise<ContentType> {
+	return new Promise(async (resolve, reject) => {
+		const command = new Command()
+		command.managementAPIClient = {host: command.cmaHost, authtoken: command.authToken}
+		const client = command.managementAPIClient
+		try {
+			const spinner = ora('Loading Content Types').start()
+			// let {items: contentTypes} = await client.stack({api_key: stackApiKey}).contentType().query({include_count: true}).find()
+			let contentTypes = await getAll(client.stack({api_key: stackApiKey}).contentType())
+			spinner.stop()
+			let contentTypeMap: any = {}
+			contentTypes.forEach((contentType: ContentType) => {
+				contentTypeMap[contentType.title] = contentType.uid
+			})
+			const contentTypeList = Object.keys(contentTypeMap)
+			let inquirerConfig = {
+				type: 'search-list',
+				name: 'chosenContentType',
+				choices: contentTypeList,
+				message: displayMessage || 'Choose a content type',
+				loop: false,
+			}
+			inquirer.prompt(inquirerConfig).then(({chosenContentType}: {chosenContentType: string}) => {
+				resolve({uid: contentTypeMap[chosenContentType], title: chosenContentType})
+			})
+		} catch (error) {
+			console.error(error.message)
+		}
+	})	
+}
+
+export function chooseEntry(contentTypeUid: string, stackApiKey: string, displayMessage?: string, region?: string): Promise<Entry> {
+	return new Promise(async (resolve, reject) => {
+		const command = new Command()
+		command.managementAPIClient = {host: command.cmaHost, authtoken: command.authToken}
+		const client = command.managementAPIClient
+		try {
+			const spinner = ora('Loading Entries').start()
+			let entries = await getAll(client.stack({api_key: stackApiKey}).contentType(contentTypeUid).entry())
+			spinner.stop()
+			let entryMap: any = {}
+			entries.forEach((entry: Entry) => {
+				entryMap[entry.title] = entry.uid
+			})
+			const entryList = Object.keys(entryMap)
+			let inquirerConfig = {
+				type: 'search-list',
+				name: 'chosenEntry',
+				choices: entryList,
+				message: displayMessage || 'Choose an entry',
+				loop: false
+			}
+			inquirer.prompt(inquirerConfig).then(({chosenEntry}: {chosenEntry: string}) => {
+				resolve({uid: entryMap[chosenEntry], title: chosenEntry})
+			})
+		} catch (error) {
+			console.error(error.message)
+		}
+	})	
+}
+
+export function chooseContentTypes(stack: any, displayMessage?: string): Promise<ContentType[]> {
+	return new Promise(async (resolve, reject) => {
+		try {
+			const spinner = ora('Loading Content Types').start()
+			// let {items: contentTypes} = await client.stack({api_key: stackApiKey}).contentType().query({include_count: true}).find()
+			let contentTypes = await getAll(stack.contentType())
+			spinner.stop()
+			let contentTypeMap: any = {}
+			contentTypes.forEach((contentType: ContentType) => {
+				contentTypeMap[contentType.title] = contentType.uid
+			})
+			const contentTypeList = Object.keys(contentTypeMap)
+			let inquirerConfig = {
+				type: 'search-checkbox',
+				name: 'chosenContentTypes',
+				choices: contentTypeList,
+				message: displayMessage || 'Choose a content type',
+				loop: false,
+			}
+			inquirer.prompt(inquirerConfig).then(({ chosenContentTypes }: { chosenContentTypes: string[]}) => {
+				let result: ContentType[] = chosenContentTypes.map(ct => {
+					let foo: ContentType = { uid: contentTypeMap[ct], title: ct }
+					return foo
+				})
+				resolve(result)
+			})
+		} catch (error) {
+			console.error(error.message)
+		}
+	})	
+}
+
+export function chooseEnvironments(stack: any, displayMessage?: string): Promise<Environment[]> {
+	return new Promise(async (resolve, reject) => {
+		try {
+			const spinner = ora('Loading Environments').start()
+			// let {items: contentTypes} = await client.stack({api_key: stackApiKey}).contentType().query({include_count: true}).find()
+			let environments = await getAll(stack.environment())
+			spinner.stop()
+			let environmentMap: any = {}
+			environments.forEach((environment: Environment) => {
+				environmentMap[environment.name] = environment.uid
+			})
+			const environmentList = Object.keys(environmentMap)
+			let inquirerConfig = {
+				type: 'search-checkbox',
+				name: 'chosenEnvironments',
+				choices: environmentList,
+				message: displayMessage || 'Choose an environment',
+				loop: false,
+				validate: shouldNotBeEmpty
+			}
+			inquirer.prompt(inquirerConfig).then(({ chosenEnvironments }: { chosenEnvironments: string[] }) => {
+				let result: Environment[] = chosenEnvironments.map(env => {
+					let foo: Environment = { uid: environmentMap[env], name: env }
+					return foo
+				})
+				resolve(result)
+			})
+		} catch (error) {
+			console.error(error.message)
+		}
+	})
+}
+
+export function chooseEnvironment(stack: any, displayMessage?: string): Promise<Environment> {
+	return new Promise(async (resolve, reject) => {
+		try {
+			const spinner = ora('Loading Environments').start()
+			// let {items: contentTypes} = await client.stack({api_key: stackApiKey}).contentType().query({include_count: true}).find()
+			let environments = await getAll(stack.environment())
+			spinner.stop()
+			let environmentMap: any = {}
+			environments.forEach((environment: Environment) => {
+				environmentMap[environment.name] = environment.uid
+			})
+			const environmentList = Object.keys(environmentMap)
+			let inquirerConfig = {
+				type: 'search-list',
+				name: 'chosenEnvironment',
+				choices: environmentList,
+				message: displayMessage || 'Choose an environment',
+				loop: false,
+				validate: shouldNotBeEmpty
+			}
+			inquirer.prompt(inquirerConfig).then(({ chosenEnvironment }: { chosenEnvironment: string }) => {
+				let result: Environment = { uid: environmentMap[chosenEnvironment], name: chosenEnvironment }
+				resolve(result)
+			})
+		} catch (error) {
+			console.error(error.message)
+		}
+	})
+}
+
+export function chooseLocales(stack: any, displayMessage?: string): Promise<Locale[]> {
+	return new Promise(async (resolve, reject) => {
+		try {
+			const spinner = ora('Loading Locales').start()
+			// let {items: contentTypes} = await client.stack({api_key: stackApiKey}).contentType().query({include_count: true}).find()
+			let locales = await getAll(stack.locale())
+			spinner.stop()
+			let localeMap: any = {}
+			locales.forEach((locale: Locale) => {
+				localeMap[locale.name] = locale.code
+			})
+			const localeList = Object.keys(localeMap)
+			let inquirerConfig = {
+				type: 'search-checkbox',
+				name: 'chosenLocales',
+				choices: localeList,
+				message: displayMessage || 'Choose locales',
+				loop: false,
+				validate: shouldNotBeEmpty,
+			}
+			inquirer.prompt(inquirerConfig).then(({ chosenLocales }: { chosenLocales: string[] }) => {
+				let result: Locale[] = chosenLocales.map(locale => {
+					let foo: Locale = { code: localeMap[locale], name: locale }
+					return foo
+				})
+				resolve(result)
+			})
+		} catch (error) {
+			console.error(error.message)
+		}
+	})
+}
+
+export function chooseLocale(stack: any, displayMessage?: string): Promise<Locale> {
+	return new Promise(async (resolve, reject) => {
+		try {
+			const spinner = ora('Loading Locales').start()
+			// let {items: contentTypes} = await client.stack({api_key: stackApiKey}).contentType().query({include_count: true}).find()
+			let locales = await getAll(stack.locale())
+			spinner.stop()
+			let localeMap: any = {}
+			locales.forEach((locale: Locale) => {
+				localeMap[locale.name] = locale.code
+			})
+			const localeList = Object.keys(localeMap)
+			let inquirerConfig = {
+				type: 'search-list',
+				name: 'chosenLocale',
+				choices: localeList,
+				message: displayMessage || 'Choose locale',
+				loop: false,
+				validate: shouldNotBeEmpty
+			}
+			inquirer.prompt(inquirerConfig).then(({ chosenLocale }: { chosenLocale: string }) => {
+				let result: Locale = { code: localeMap[chosenLocale], name: chosenLocale }
+				resolve(result)
+			})
+		} catch (error) {
+			console.error(error.message)
+		}
+	})
+}
+
+export function chooseTokenAlias(): Promise<Token> {
+	return new Promise(async (resolve, reject) => {
+		const tokens = config.get('tokens')
+		const tokenList = Object.keys(tokens).filter((token: string) => tokens[token].type === 'management')
+		let inquirerConfig = {
+			type: 'search-list',
+			name: 'chosenToken',
+			choices: tokenList,
+			message: 'Choose an alias to use',
+			loop: false,
+			validate: shouldNotBeEmpty,
+		}
+		inquirer.prompt(inquirerConfig).then(({ chosenToken }: { chosenToken: string }) => {
+			resolve({ apiKey: tokens[chosenToken].apiKey, token: tokens[chosenToken].token })
+		})
+	})
+}
+
+export function chooseDeliveryTokenAlias(): Promise<Token> {
+	return new Promise(async (resolve, reject) => {
+		const tokens = config.get('tokens')
+		const tokenList = Object.keys(tokens).filter((token: string) => tokens[token].type === 'delivery')
+		let inquirerConfig = {
+			type: 'search-list',
+			name: 'chosenToken',
+			choices: tokenList,
+			message: 'Choose an alias to use',
+			loop: false,
+			validate: shouldNotBeEmpty,
+		}
+		inquirer.prompt(inquirerConfig).then(({ chosenToken }: { chosenToken: string }) => {
+			resolve({ apiKey: tokens[chosenToken].apiKey, token: tokens[chosenToken].token })
+		})
+	})
+}
+
+async function getAll (element: any, skip: number=0): Promise<any> {
+	return new Promise(async resolve => {
+		let result: any[] = []
+		result = await fetch(element, skip, result)
+		resolve(result)
+	})
+}
+
+async function fetch(element: any, skip: number, accumulator: any[]): Promise<any[]> {
+	return new Promise(async resolve => {
+		let queryParams = {include_count: true, skip: skip}
+		let {items: result, count: count} = await element.query(queryParams).find()
+		accumulator = accumulator.concat(result)
+		skip += result.length
+		if (skip < count)
+			return resolve(await fetch(element, skip, accumulator))
+		return resolve(accumulator)
+	})
+}
+
+// async function callMe() {
+// 	// let organization = await chooseOrganization()
+// 	// console.log(organization)
+
+// 	// let stack = await chooseStack(organization.orgUid)
+// 	// console.log(stack)
+
+// 	// let contentType = await chooseContentType(stack.api_key)
+// 	// console.log(contentType)
+
+// 	// let entry = await chooseEntry(contentType.uid, stack.api_key)
+// 	// console.log(entry)
+
+// 	// let entry = await chooseEntry(contentType.uid, stack.api_key)
+// 	// console.log(entry)
+
+// 	let token = await chooseTokenAlias()
+// 	console.log(token)
+// }
+
+// callMe()

package/src/selectors/interfaces.ts

@@ -0,0 +1,39 @@
+export interface Token {
+  token: string;
+  apiKey: string;
+}
+
+export interface Organization {
+  uid: string,
+  name: string,
+}
+
+export interface selectedOrganization {
+  orgUid: string,
+  orgName: string,
+}
+
+export interface Stack {
+  name: string,
+  api_key: string,
+}
+
+export interface ContentType {
+  uid: string,
+  title: string,
+}
+
+export interface Environment {
+  name: string,
+  uid: string,
+}
+
+export interface Entry {
+  uid: string,
+  title: string,
+}
+
+export interface Locale {
+  name: string;
+  code: string;
+}

package/src/selectors/validations.ts

@@ -0,0 +1,5 @@
+export function shouldNotBeEmpty(input) {
+  if (input.length === 0)
+    throw new Error('Please enter a valid value')
+  return true
+}