@contentstack/cli-utilities 0.1.1-beta.1

package/.eslintignore

@@ -0,0 +1,2 @@
+# Build files
+./lib

package/.eslintrc

@@ -0,0 +1,40 @@
+{
+    "env": {
+        "node": true
+    },
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "project": "tsconfig.json",
+        "sourceType": "module"
+    },
+    "extends": [
+        "plugin:@typescript-eslint/recommended"
+    ],
+    "rules": {
+        "@typescript-eslint/no-unused-vars": [
+            "error",
+            {
+                "args": "none"
+            }
+        ],
+        "@typescript-eslint/prefer-namespace-keyword": "error",
+        "@typescript-eslint/quotes": [
+            "error",
+            "single",
+            {
+                "avoidEscape": true,
+                "allowTemplateLiterals": true
+            }
+        ],
+        "semi": "off",
+        "@typescript-eslint/type-annotation-spacing": "error",
+        "@typescript-eslint/no-redeclare": "off",
+        "eqeqeq": [
+            "error",
+            "smart"
+        ],
+        "id-match": "error",
+        "no-eval": "error",
+        "no-var": "error"
+    }
+}

package/.mocharc.json

@@ -0,0 +1,12 @@
+{
+    "require": [
+      "test/helpers/init.js",
+      "ts-node/register",
+      "source-map-support/register"
+    ],
+    "watch-extensions": [
+      "ts"
+    ],
+    "recursive": true,
+    "timeout": 5000
+  }

package/.nycrc.json

@@ -0,0 +1,5 @@
+{
+    "inlcude": [
+        "lib/**/*.js"
+    ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Contentstack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/cli-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CLIError extends Error {
+    constructor(message, suggestions) {
+        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;
+        }
+    }
+}
+exports.default = CLIError;

package/lib/cli-ux.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const cli_ux_1 = require("@oclif/core/lib/cli-ux");
+const message_handler_1 = tslib_1.__importDefault(require("./message-handler"));
+/**
+ * CLI Interface
+ */
+class CLIInterface {
+    constructor() {
+        this.loading = false;
+    }
+    get uxTable() {
+        return cli_ux_1.ux.table;
+    }
+    init(context) { }
+    print(message, opts) {
+        if (opts && opts.color) {
+            cli_ux_1.ux.log(chalk_1.default[opts.color](message_handler_1.default.parse(message)));
+            return;
+        }
+        cli_ux_1.ux.log(message_handler_1.default.parse(message));
+    }
+    success(message) {
+        cli_ux_1.ux.log(chalk_1.default.green(message_handler_1.default.parse(message)));
+    }
+    error(message, ...params) {
+        cli_ux_1.ux.log(chalk_1.default.red(message_handler_1.default.parse(message) + (params && params.length > 0 ? ': ' : '')), ...params);
+    }
+    loader(message = '') {
+        if (!this.loading) {
+            cli_ux_1.ux.action.start(message_handler_1.default.parse(message));
+        }
+        else {
+            cli_ux_1.ux.action.stop(message_handler_1.default.parse(message));
+        }
+        this.loading = !this.loading;
+    }
+    table(data, columns, options) {
+        cli_ux_1.ux.table(data, columns, options);
+    }
+    async inquire(inquirePayload) {
+        inquirePayload.message = message_handler_1.default.parse(inquirePayload.message);
+        const result = await inquirer_1.default.prompt(inquirePayload);
+        return result[inquirePayload.name];
+    }
+    prompt(name, options) {
+        return cli_ux_1.ux.prompt(name, options);
+    }
+    confirm(message) {
+        return cli_ux_1.ux.confirm(message);
+    }
+    progress(options) {
+        return cli_ux_1.ux.progress(options);
+    }
+}
+exports.default = new CLIInterface();

package/lib/config-handler.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const conf_1 = tslib_1.__importDefault(require("conf"));
+const uuid_1 = require("uuid");
+const fs_1 = require("fs");
+const ENC_KEY = 'encryptionKey';
+const ENCRYPT_CONF = true;
+const CONFIG_NAME = 'contentstack_cli';
+const ENC_CONFIG_NAME = 'contentstack_cli_obfuscate';
+class Config {
+    constructor() {
+        this.init();
+    }
+    init() {
+        return ENCRYPT_CONF === true
+            ? this.getEncryptedConfig()
+            : this.getDecryptedConfig();
+    }
+    fallbackInit() {
+        return new conf_1.default({ configName: CONFIG_NAME, encryptionKey: ENC_KEY });
+    }
+    getObfuscationKey() {
+        const obfuscationKeyName = 'obfuscation_key';
+        const encConfig = new conf_1.default({ configName: ENC_CONFIG_NAME });
+        let obfuscationKey = encConfig.get(obfuscationKeyName);
+        if (!obfuscationKey) {
+            encConfig.set(obfuscationKeyName, (0, uuid_1.v4)());
+            obfuscationKey = encConfig.get(obfuscationKeyName);
+        }
+        return obfuscationKey;
+    }
+    getConfigDataAndUnlinkConfigFile(config) {
+        let configData;
+        if (config === null || config === void 0 ? void 0 : config.path) {
+            if ((0, fs_1.existsSync)(config.path)) {
+                configData = JSON.parse(JSON.stringify((config === null || config === void 0 ? void 0 : config.store) || {})); // NOTE convert prototype object to plain object
+                (0, fs_1.unlinkSync)(config.path); // NOTE remove old config file
+            }
+        }
+        return configData;
+    }
+    getEncryptedConfig(configData, skip = false) {
+        const getEncryptedDataElseFallBack = () => {
+            var _a;
+            try {
+                // NOTE reading current code base encrypted file if exist
+                const encryptionKey = this.getObfuscationKey();
+                this.config = new conf_1.default({ configName: CONFIG_NAME, encryptionKey });
+                if ((_a = Object.keys(configData || {})) === null || _a === void 0 ? void 0 : _a.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_1.default({ 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;
+    }
+    getDecryptedConfig(configData) {
+        var _a;
+        try {
+            this.config = new conf_1.default({ configName: CONFIG_NAME });
+            if ((_a = Object.keys(configData || {})) === null || _a === void 0 ? void 0 : _a.length) {
+                this.config.set(configData); // NOTE set config data if passed any
+            }
+        }
+        catch (error) {
+            // console.trace(error.message)
+            try {
+                const encryptionKey = this.getObfuscationKey();
+                let config = new conf_1.default({ 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) {
+        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();
+    }
+}
+exports.default = new Config();

package/lib/flag-deprecation-check.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const cli_ux_1 = tslib_1.__importDefault(require("./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
+ */
+function default_1(deprecatedFlags = [], suggestions = [], customMessage) {
+    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(', ')}).`;
+                }
+            }
+            cli_ux_1.default.print(depreactionMessage, { color: 'yellow' });
+        }
+        return input;
+    };
+}
+exports.default = default_1;

package/lib/http-client/client.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const http_response_1 = require("./http-response");
+class HttpClient {
+    /**
+     * Createa new pending HTTP request instance.
+     */
+    constructor() {
+        /**
+         * The payload format for a JSON or form-url-encoded request.
+         */
+        this.bodyFormat = 'json';
+        this.request = {};
+        this.axiosInstance = axios_1.default.create();
+        // Sets payload format as json by default
+        this.asJson();
+    }
+    /**
+     * Create a reusable HttpClient instance.
+     *
+     * @returns {HttpClient}
+     */
+    static create() {
+        return new this();
+    }
+    /**
+     * Returns the Axios request config.
+     *
+     * @returns {AxiosRequestConfig}
+     */
+    requestConfig() {
+        return this.request;
+    }
+    /**
+     * Resets the request config.
+     *
+     * @returns {AxiosRequestConfig}
+     */
+    resetConfig() {
+        this.request = {};
+        return this;
+    }
+    /**
+     * Use the given `baseUrl` for all requests.
+     *
+     * @param {String} baseUrl
+     *
+     * @returns {HttpClient}
+     */
+    baseUrl(baseUrl) {
+        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) {
+        this.request.headers = Object.assign(Object.assign({}, this.request.headers), headers);
+        return this;
+    }
+    /**
+     * Add query parameters to the request.
+     *
+     * @param {Object} queryParams
+     *
+     * @returns {HttpClient}
+     */
+    queryParams(queryParams) {
+        this.request.params = Object.assign(Object.assign({}, 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, password) {
+        this.request.auth = { username, password };
+        return this;
+    }
+    /**
+     * Add an authorization `token` to the request.
+     *
+     * @param {String} token
+     * @param {String} type
+     *
+     * @returns {HttpClient}
+     */
+    token(token, type = 'Bearer') {
+        return this.headers({
+            Authorization: `${type} ${token}`.trim(),
+        });
+    }
+    /**
+     * Merge your own custom Axios options into the request.
+     *
+     * @param {Object} options
+     *
+     * @returns {HttpClient}
+     */
+    options(options = {}) {
+        Object.assign(this.request, options);
+        return this;
+    }
+    /**
+     * Add a request payload.
+     *
+     * @param {*} data
+     *
+     * @returns {HttpClient}
+     */
+    payload(data) {
+        this.request.data = data;
+        return this;
+    }
+    /**
+     * Define the request `timeout` in milliseconds.
+     *
+     * @param {Number} timeout
+     *
+     * @returns {HttpClient}
+     */
+    timeout(timeout) {
+        this.request.timeout = timeout;
+        return this;
+    }
+    /**
+     * Tell HttpClient to send the request as JSON payload.
+     *
+     * @returns {HttpClient}
+     */
+    asJson() {
+        return this.payloadFormat('json').contentType('application/json');
+    }
+    /**
+     * Tell HttpClient to send the request as form parameters,
+     * encoded as URL query parameters.
+     *
+     * @returns {HttpClient}
+     */
+    asFormParams() {
+        return this.payloadFormat('formParams').contentType('application/x-www-form-urlencoded');
+    }
+    /**
+     * Set the request payload format.
+     *
+     * @param {String} format
+     *
+     * @returns {HttpClient}
+     */
+    payloadFormat(format) {
+        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) {
+        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() {
+        return this.accept('application/json');
+    }
+    /**
+     * Set the `Content-Type` request header.
+     *
+     * @param {String} contentType
+     *
+     * @returns {HttpClient}
+     */
+    contentType(contentType) {
+        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(url, queryParams = {}) {
+        this.queryParams(queryParams);
+        return this.send('GET', url);
+    }
+    /**
+     * Send an HTTP POST request, optionally with the given `payload`.
+     *
+     * @param {String} url
+     * @param {Object} payload
+     *
+     * @returns {HttpResponse}
+     *
+     * @throws
+     */
+    async post(url, payload) {
+        if (payload) {
+            this.payload(payload);
+        }
+        return this.send('POST', url);
+    }
+    /**
+     * Send an HTTP PUT request, optionally with the given `payload`.
+     *
+     * @param {String} url
+     * @param {Object} payload
+     *
+     * @returns {HttpResponse}
+     *
+     * @throws
+     */
+    async put(url, payload) {
+        if (payload) {
+            this.payload(payload);
+        }
+        return this.send('PUT', url);
+    }
+    /**
+     * Send an HTTP PATCH request, optionally with the given `payload`.
+     *
+     * @param {String} url
+     * @param {Object} payload
+     *
+     * @returns {HttpResponse}
+     *
+     * @throws
+     */
+    async patch(url, payload) {
+        if (payload) {
+            this.payload(payload);
+        }
+        return this.send('PATCH', url);
+    }
+    /**
+     * Send an HTTP DELETE request, optionally with the given `queryParams`.
+     *
+     * @param {String} url
+     * @param {Object} queryParams
+     *
+     * @returns {HttpResponse}
+     *
+     * @throws
+     */
+    async delete(url, queryParams = {}) {
+        this.queryParams(queryParams);
+        return this.send('DELETE', url);
+    }
+    /**
+     * Send the HTTP request.
+     *
+     * @param {String} method
+     * @param {String} url
+     *
+     * @returns {HttpResponse}
+     *
+     * @throws
+     */
+    async send(method, url) {
+        try {
+            return new http_response_1.HttpResponse(await this.createAndSendRequest(method, url));
+        }
+        catch (error) {
+            if (error.response) {
+                return new http_response_1.HttpResponse(error.response);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Create and send the HTTP request.
+     *
+     * @param {String} method
+     * @param {String} url
+     *
+     * @returns {Request}
+     */
+    async createAndSendRequest(method, url) {
+        return await this.axiosInstance(Object.assign(Object.assign({ url,
+            method, withCredentials: true }, this.request), { data: this.prepareRequestPayload() }));
+    }
+    /**
+     * Returns the request payload depending on the selected request payload format.
+     */
+    prepareRequestPayload() {
+        return this.bodyFormat === 'formParams' ? new URLSearchParams(this.request.data).toString() : this.request.data;
+    }
+}
+exports.HttpClient = HttpClient;

package/lib/http-client/http-response.js

@@ -0,0 +1,46 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpResponse = void 0;
+class HttpResponse {
+    /**
+     * Wrap the given Axios `response` into a new response instance.
+     *
+     * @param {AxiosResponse} response
+     */
+    constructor(response) {
+        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;
+    }
+}
+exports.HttpResponse = HttpResponse;

package/lib/http-client/index.js

@@ -0,0 +1,7 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const client_1 = require("./client");
+exports.default = client_1.HttpClient;
+tslib_1.__exportStar(require("./client"), exports);
+tslib_1.__exportStar(require("./http-response"), exports);