@contentstack/apps-cli 1.0.0

package/lib/types/utils.d.ts

@@ -0,0 +1,18 @@
+import { Color } from "chalk";
+import { PrintOptions } from "@contentstack/cli-utilities";
+import config from "../config";
+type LogFn = (message: string | any, logType?: LoggerType | PrintOptions | undefined) => void;
+type ExitFn = (code?: number | undefined) => void;
+type Partial<T> = {
+    [P in keyof T]?: T[P];
+};
+type ConfigType = {
+    config?: string;
+} & typeof config & Record<string, any>;
+export { LogFn, ExitFn, Partial, ConfigType };
+export type LoggerType = "info" | "warn" | "error" | "debug";
+export type PrintType = {
+    message: string;
+    bold?: boolean;
+    color?: typeof Color;
+};

package/lib/types/utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/util/common-utils.d.ts

@@ -0,0 +1,18 @@
+import { ContentstackClient, FlagInput } from "@contentstack/cli-utilities";
+import { Extension, LogFn } from "../types";
+import { Stack } from "@contentstack/cli-utilities";
+export type CommonOptions = {
+    log: LogFn;
+    managementSdk: ContentstackClient;
+};
+declare function getOrganizations(options: CommonOptions, skip?: number, organizations?: Record<string, any>[]): Promise<Record<string, any>[]>;
+declare function getOrgAppUiLocation(): Extension[];
+declare function fetchApps(flags: FlagInput, orgUid: string, options: CommonOptions, skip?: number, apps?: Record<string, any>[]): Promise<Record<string, any>[]>;
+declare function fetchApp(flags: FlagInput, orgUid: string, options: CommonOptions): Promise<import("@contentstack/management/types/app").App>;
+declare function fetchAppInstallations(flags: FlagInput, orgUid: string, options: CommonOptions): Promise<import("@contentstack/management/types/contentstackCollection").ContentstackCollection<import("@contentstack/management/types/app/installation").Installation>>;
+declare function deleteApp(flags: FlagInput, orgUid: string, options: CommonOptions): Promise<import("@contentstack/management/types/app").App>;
+declare function installApp(flags: FlagInput, orgUid: string, type: string, options: CommonOptions): Promise<import("@contentstack/management/types/app/installation").Installation>;
+declare function fetchStack(flags: FlagInput, options: CommonOptions): Promise<import("@contentstack/management/types/stack").Stack>;
+declare function getStacks(options: CommonOptions, orgUid: string, skip?: number, stacks?: Stack[]): Promise<Stack[]>;
+declare function uninstallApp(flags: FlagInput, orgUid: string, options: CommonOptions): Promise<import("@contentstack/management/types/utility/fields").AnyProperty>;
+export { getOrganizations, getOrgAppUiLocation, fetchApps, fetchApp, fetchAppInstallations, deleteApp, installApp, getStacks, fetchStack, uninstallApp };

package/lib/util/common-utils.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uninstallApp = exports.fetchStack = exports.getStacks = exports.installApp = exports.deleteApp = exports.fetchAppInstallations = exports.fetchApp = exports.fetchApps = exports.getOrgAppUiLocation = exports.getOrganizations = void 0;
+const types_1 = require("../types");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+async function getOrganizations(options, skip = 0, organizations = []) {
+    const { log, managementSdk } = options;
+    const response = await managementSdk
+        .organization()
+        .fetchAll({ limit: 100, asc: "name", include_count: true, skip: skip })
+        .catch((error) => {
+        log("Unable to fetch organizations.", "warn");
+        log(error, "error");
+        throw error;
+    });
+    if (response) {
+        organizations = organizations.concat(response.items);
+        if (organizations.length < response.count) {
+            organizations = await getOrganizations(options, skip + 100);
+        }
+    }
+    return organizations;
+}
+exports.getOrganizations = getOrganizations;
+function getOrgAppUiLocation() {
+    const orgConfigLocation = {
+        type: types_1.AppLocation.ORG_CONFIG,
+        meta: [
+            {
+                path: "/app-configuration",
+                signed: true,
+                enabled: true,
+            },
+        ],
+    };
+    return [orgConfigLocation];
+}
+exports.getOrgAppUiLocation = getOrgAppUiLocation;
+async function fetchApps(flags, orgUid, options, skip = 0, apps = []) {
+    const { log, managementSdk } = options;
+    const response = await managementSdk
+        .organization(orgUid)
+        .app()
+        .findAll({
+        limit: 50,
+        asc: "name",
+        include_count: true,
+        skip: skip,
+        target_type: flags["app-type"],
+    })
+        .catch((error) => {
+        cli_utilities_1.cliux.loader("failed");
+        log("Some error occurred while fetching apps.", "warn");
+        log(error.errorMessage, "error");
+        throw error;
+    });
+    if (response) {
+        apps = apps.concat(response.items);
+        if (apps.length < response.count) {
+            apps = await fetchApps(flags, orgUid, options, skip + 50, apps);
+        }
+    }
+    return apps;
+}
+exports.fetchApps = fetchApps;
+function fetchApp(flags, orgUid, options) {
+    const { managementSdk } = options;
+    const app = flags["app-uid"];
+    return managementSdk
+        .organization(orgUid)
+        .app(app)
+        .fetch();
+}
+exports.fetchApp = fetchApp;
+function fetchAppInstallations(flags, orgUid, options) {
+    const { managementSdk } = options;
+    const app = flags["app-uid"];
+    return managementSdk
+        .organization(orgUid)
+        .app(app)
+        .installation()
+        .findAll()
+        .catch(error => {
+        const { log } = options;
+        cli_utilities_1.cliux.loader("failed");
+        log("Some error occurred while fetching app installations.", "warn");
+        throw error; // throwing error here instead of removing the catch block, as the loader needs to stopped in case there is an error.
+    });
+}
+exports.fetchAppInstallations = fetchAppInstallations;
+function deleteApp(flags, orgUid, options) {
+    const { managementSdk } = options;
+    const app = flags["app-uid"];
+    return managementSdk
+        .organization(orgUid)
+        .app(app)
+        .delete();
+}
+exports.deleteApp = deleteApp;
+function installApp(flags, orgUid, type, options) {
+    const { managementSdk } = options;
+    return managementSdk
+        .organization(orgUid)
+        .app(flags["app-uid"])
+        .install({
+        targetUid: flags["stack-api-key"] || orgUid,
+        targetType: type,
+    });
+}
+exports.installApp = installApp;
+function fetchStack(flags, options) {
+    const { managementSdk } = options;
+    return managementSdk
+        .stack({ api_key: flags["stack-api-key"] })
+        .fetch();
+}
+exports.fetchStack = fetchStack;
+async function getStacks(options, orgUid, skip = 0, stacks = []) {
+    const { log, managementSdk } = options;
+    const response = await managementSdk
+        .organization(orgUid)
+        .stacks({ include_count: true, limit: 100, asc: "name", skip: skip })
+        .catch((error) => {
+        cli_utilities_1.cliux.loader("failed");
+        log("Unable to fetch stacks.", "warn");
+        log((error === null || error === void 0 ? void 0 : error.errorMessage) || error, "error");
+        throw error;
+    });
+    if (response) {
+        stacks = stacks.concat(response.items);
+        if (stacks.length < response.count) {
+            stacks = await getStacks(options, orgUid, skip + 100, stacks);
+        }
+    }
+    return stacks;
+}
+exports.getStacks = getStacks;
+function uninstallApp(flags, orgUid, options) {
+    const { managementSdk } = options;
+    const app = flags['app-uid'];
+    const installationUid = flags['installation-uid'];
+    return managementSdk
+        .organization(orgUid)
+        .app(app)
+        .installation(installationUid)
+        .uninstall();
+}
+exports.uninstallApp = uninstallApp;

package/lib/util/fs.d.ts

@@ -0,0 +1,2 @@
+import { LogFn } from "../types";
+export declare function writeFile(dir?: string, force?: boolean, data?: Record<string, any> | undefined, log?: LogFn): Promise<void>;

package/lib/util/fs.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFile = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_1 = tslib_1.__importDefault(require("../config"));
+const messages_1 = tslib_1.__importStar(require("../messages"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+async function writeFile(dir = process.cwd(), force = false, data = {}, log = console.log) {
+    var _a;
+    await ensureDirectoryExists(dir);
+    const files = (0, fs_1.readdirSync)(dir);
+    const latestFileName = ((_a = files.filter(fileName => fileName.match(new RegExp(config_1.default.defaultAppFileName))).pop()) === null || _a === void 0 ? void 0 : _a.split('.')[0]) || config_1.default.defaultAppFileName;
+    let target = (0, path_1.resolve)(dir, `${latestFileName}.json`);
+    if ((0, fs_1.existsSync)(target)) {
+        const userConfirmation = force || (await cli_utilities_1.cliux.confirm((0, messages_1.$t)(messages_1.default.FILE_ALREADY_EXISTS, { file: `${config_1.default.defaultAppFileName}.json` })));
+        if (userConfirmation) {
+            target = (0, path_1.resolve)(dir, `${config_1.default.defaultAppFileName}.json`);
+        }
+        else {
+            target = (0, path_1.resolve)(dir, `${incrementName(latestFileName)}.json`);
+        }
+    }
+    await (0, fs_1.writeFileSync)(target, JSON.stringify(data));
+    log((0, messages_1.$t)(messages_1.default.FILE_WRITTEN_SUCCESS, { file: target }), "info");
+}
+exports.writeFile = writeFile;
+async function ensureDirectoryExists(dir) {
+    if (!(0, fs_1.existsSync)(dir)) {
+        await (0, fs_1.mkdirSync)(dir, { recursive: true });
+    }
+}
+function incrementName(name) {
+    return `${config_1.default.defaultAppFileName}${Number(name.split(config_1.default.defaultAppFileName).pop()) + 1}`;
+}

package/lib/util/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./fs";
+export * from "./inquirer";
+export * from "./common-utils";
+export { default as Logger } from "./log";

package/lib/util/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./fs"), exports);
+tslib_1.__exportStar(require("./inquirer"), exports);
+tslib_1.__exportStar(require("./common-utils"), exports);
+var log_1 = require("./log");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return tslib_1.__importDefault(log_1).default; } });

package/lib/util/inquirer.d.ts

@@ -0,0 +1,34 @@
+import { FlagInput, ContentstackClient } from "@contentstack/cli-utilities";
+import { AppTarget } from '@contentstack/management/types/app/index';
+import { CommonOptions } from "./common-utils";
+/**
+ * @method getAppName
+ *
+ * @return {*}  {(Promise<string | boolean>)}
+ */
+declare function getAppName(defaultName?: string): Promise<string | boolean>;
+/**
+ * @method getDirName
+ *
+ * @param {string} [defaultName=""]
+ * @return {*}  {(Promise<string | boolean>)}
+ */
+declare function getDirName(path: string): Promise<string>;
+/**
+ * @method getOrg
+ *
+ * @param {FlagInput} flags
+ * @param {CommonOptions} options
+ * @return {*}
+ */
+declare function getOrg(flags: FlagInput, options: CommonOptions): Promise<import("@oclif/core/lib/interfaces/parser").CompletableFlag<any>>;
+declare function getApp(flags: FlagInput, orgUid: string, options: CommonOptions): Promise<Record<string, any> | undefined>;
+/**
+ * @method getDeveloperHubUrl
+ *
+ * @return {*}  {Promise<string>}
+ */
+declare function getDeveloperHubUrl(): Promise<string>;
+declare function getStack(orgUid: string, options: CommonOptions): Promise<Record<string, any> | undefined>;
+declare function getInstallation(flags: FlagInput, orgUid: string, managementSdkForStacks: ContentstackClient, appType: AppTarget, options: CommonOptions): Promise<string>;
+export { getOrg, getAppName, getDirName, getDeveloperHubUrl, getApp, getStack, getInstallation };

package/lib/util/inquirer.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstallation = exports.getStack = exports.getApp = exports.getDeveloperHubUrl = exports.getDirName = exports.getAppName = exports.getOrg = void 0;
+const tslib_1 = require("tslib");
+const find_1 = tslib_1.__importDefault(require("lodash/find"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const config_1 = tslib_1.__importDefault(require("../config"));
+const messages_1 = tslib_1.__importStar(require("../messages"));
+const common_utils_1 = require("./common-utils");
+/**
+ * @method getAppName
+ *
+ * @return {*}  {(Promise<string | boolean>)}
+ */
+async function getAppName(defaultName = "") {
+    return cli_utilities_1.cliux.inquire({
+        type: "input",
+        name: "appName",
+        default: defaultName,
+        message: (0, messages_1.$t)(messages_1.default.NAME, { target: "App" }),
+        validate: (name) => {
+            if (name.length < 3 || name.length > 20) {
+                return (0, messages_1.$t)(messages_1.errors.INVALID_NAME, { min: "3", max: "20" });
+            }
+            return true;
+        },
+    });
+}
+exports.getAppName = getAppName;
+/**
+ * @method getDirName
+ *
+ * @param {string} [defaultName=""]
+ * @return {*}  {(Promise<string | boolean>)}
+ */
+async function getDirName(path) {
+    const basePath = (0, path_1.dirname)(path);
+    const defaultName = (0, path_1.basename)(path);
+    return cli_utilities_1.cliux
+        .inquire({
+        type: "input",
+        name: "dirName",
+        default: defaultName,
+        message: (0, messages_1.$t)(messages_1.default.NAME, { target: "Directory" }),
+        validate: (name) => {
+            if (name.length < 3 || name.length > 30) {
+                return (0, messages_1.$t)(messages_1.errors.INVALID_NAME, { min: "3", max: "50" });
+            }
+            if ((0, fs_1.existsSync)((0, path_1.join)(basePath, name))) {
+                return messages_1.default.DIR_EXIST;
+            }
+            return true;
+        },
+    })
+        .then((name) => (0, path_1.join)(basePath, name));
+}
+exports.getDirName = getDirName;
+/**
+ * @method getOrg
+ *
+ * @param {FlagInput} flags
+ * @param {CommonOptions} options
+ * @return {*}
+ */
+async function getOrg(flags, options) {
+    const organizations = (await (0, common_utils_1.getOrganizations)(options)) || [];
+    if (!(flags.org && (0, find_1.default)(organizations, { uid: flags.org }))) {
+        if (flags.org) {
+            throw new Error(messages_1.default.ORG_UID_NOT_FOUND);
+        }
+        flags.org = await cli_utilities_1.cliux
+            .inquire({
+            type: "search-list",
+            name: "Organization",
+            choices: organizations,
+            message: messages_1.default.CHOOSE_ORG,
+        })
+            .then((name) => { var _a; return (_a = (0, find_1.default)(organizations, { name })) === null || _a === void 0 ? void 0 : _a.uid; });
+    }
+    return flags.org;
+}
+exports.getOrg = getOrg;
+async function getApp(flags, orgUid, options) {
+    cli_utilities_1.cliux.loader("Loading Apps");
+    const apps = (await (0, common_utils_1.fetchApps)(flags, orgUid, options)) || [];
+    cli_utilities_1.cliux.loader("done");
+    if (apps.length === 0) {
+        throw new Error(messages_1.default.APPS_NOT_FOUND);
+    }
+    flags.app = await cli_utilities_1.cliux
+        .inquire({
+        type: "search-list",
+        name: "App",
+        choices: apps,
+        message: messages_1.default.CHOOSE_APP
+    })
+        .then((name) => { var _a; return (_a = apps.find(app => app.name === name)) === null || _a === void 0 ? void 0 : _a.uid; });
+    return apps.find(app => app.uid === flags.app);
+}
+exports.getApp = getApp;
+/**
+ * @method getDeveloperHubUrl
+ *
+ * @return {*}  {Promise<string>}
+ */
+async function getDeveloperHubUrl() {
+    const { cma, name } = cli_utilities_1.configHandler.get("region") || {};
+    let developerHubBaseUrl = config_1.default.developerHubUrls[cma];
+    if (!developerHubBaseUrl) {
+        developerHubBaseUrl = await cli_utilities_1.cliux.inquire({
+            type: "input",
+            name: "name",
+            validate: (url) => {
+                if (!url)
+                    return messages_1.errors.BASE_URL_EMPTY;
+                return true;
+            },
+            message: (0, messages_1.$t)(messages_1.commonMsg.DEVELOPER_HUB_URL_PROMPT, { name }),
+        });
+    }
+    if (developerHubBaseUrl.startsWith("http")) {
+        developerHubBaseUrl = developerHubBaseUrl.split("//")[1];
+    }
+    return developerHubBaseUrl;
+}
+exports.getDeveloperHubUrl = getDeveloperHubUrl;
+async function getStack(orgUid, options) {
+    cli_utilities_1.cliux.loader("Loading Stacks");
+    const stacks = (await (0, common_utils_1.getStacks)(options, orgUid)) || [];
+    cli_utilities_1.cliux.loader("done");
+    if (stacks.length === 0) {
+        // change this to stacks not found
+        throw new Error(messages_1.default.APPS_NOT_FOUND);
+    }
+    const selectedStack = await cli_utilities_1.cliux
+        .inquire({
+        type: "search-list",
+        name: "Stack",
+        choices: stacks,
+        message: messages_1.default.CHOOSE_A_STACK
+    })
+        .then((name) => stacks.find(stack => stack.name === name));
+    return selectedStack;
+}
+exports.getStack = getStack;
+async function getInstallation(flags, orgUid, managementSdkForStacks, appType, options) {
+    var _a;
+    const { log } = options;
+    if (appType === 'stack') {
+        cli_utilities_1.cliux.loader("Loading App Installations");
+    }
+    let { items: installations } = (await (0, common_utils_1.fetchAppInstallations)(flags, orgUid, options)) || [];
+    // console.log(installations)
+    if (!(installations === null || installations === void 0 ? void 0 : installations.length)) {
+        if (appType === "stack")
+            cli_utilities_1.cliux.loader("done");
+        throw new Error(messages_1.default.NO_INSTALLATIONS_FOUND);
+    }
+    let selectedInstallation;
+    if (appType === 'stack') {
+        // fetch stacks from where the app has to be uninstalled
+        cli_utilities_1.cliux.loader("done");
+        const stacks = await (0, common_utils_1.getStacks)({ managementSdk: managementSdkForStacks, log: options.log }, orgUid);
+        installations = populateMissingDataInInstallations(installations, stacks);
+        selectedInstallation = await cli_utilities_1.cliux
+            .inquire({
+            type: 'search-list',
+            name: 'appInstallation',
+            choices: installations,
+            message: messages_1.default.CHOOSE_AN_INSTALLATION
+        });
+    }
+    else {
+        // as this is an organization app, and it is supposed to only be installed on the source organization
+        // it will be uninstalled from the selected organization
+        selectedInstallation = ((_a = installations.pop()) === null || _a === void 0 ? void 0 : _a.uid) || "";
+    }
+    log((0, messages_1.$t)(messages_1.uninstallAppMsg.UNINSTALLING_APP, {
+        type: appType
+    }), "info");
+    return selectedInstallation;
+}
+exports.getInstallation = getInstallation;
+function populateMissingDataInInstallations(installations, stacks) {
+    let result = installations.map(installation => {
+        var _a;
+        let stack = (_a = stacks.filter(stack => stack.api_key === installation.target.uid)) === null || _a === void 0 ? void 0 : _a.pop();
+        installation.name = (stack === null || stack === void 0 ? void 0 : stack.name) || installation.target.uid;
+        installation.value = installation.uid;
+        return installation;
+    });
+    if (result.length > 0) {
+        return result;
+    }
+    return installations;
+}

package/lib/util/log.d.ts

@@ -0,0 +1,41 @@
+import winston from "winston";
+import { PrintOptions } from "@contentstack/cli-utilities";
+import { LoggerType, PrintType } from "../types";
+export default class Logger {
+    private infoLogger;
+    private errorLogger;
+    private config;
+    get loggerOptions(): winston.transports.FileTransportOptions;
+    constructor(config: Record<string, any>);
+    /**
+     * @method getLoggerInstance - init/generate new winston logger instance
+     *
+     * @param {LoggerType} logType
+     * @return {*}  {winston.Logger}
+     * @memberof Logger
+     */
+    getLoggerInstance(logType: LoggerType): winston.Logger;
+    /**
+     * @method log - log/print message with log type (error, info, warn)
+     *
+     * @param {(string | any)} message
+     * @param {(LoggerType | PrintOptions | undefined)} [logType]
+     * @memberof Logger
+     */
+    log(message: string | any, logType?: LoggerType | PrintOptions | undefined): void;
+    /**
+     * @method returnString - formate error and return as string without any credentials
+     *
+     * @param {*} message
+     * @return {*}  {string}
+     * @memberof Logger
+     */
+    returnString(message: any): string;
+}
+/**
+ * @method print - print message on UI
+ *
+ * @export print
+ * @param {Array<PrintType>} printInput
+ */
+export declare function print(printInput: Array<PrintType>): void;

package/lib/util/log.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.print = void 0;
+const tslib_1 = require("tslib");
+const map_1 = tslib_1.__importDefault(require("lodash/map"));
+const winston_1 = tslib_1.__importDefault(require("winston"));
+const fs_1 = require("fs");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const replace_1 = tslib_1.__importDefault(require("lodash/replace"));
+const path_1 = require("path");
+const isObject_1 = tslib_1.__importDefault(require("lodash/isObject"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const ansiRegexPattern = [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))",
+].join("|");
+const customLevels = {
+    levels: {
+        warn: 1,
+        info: 2,
+        debug: 3,
+    },
+};
+class Logger {
+    get loggerOptions() {
+        return {
+            filename: "",
+            maxFiles: 20,
+            tailable: true,
+            maxsize: 1000000,
+        };
+    }
+    constructor(config) {
+        this.config = config;
+        this.infoLogger = this.getLoggerInstance("info");
+        this.errorLogger = this.getLoggerInstance("error");
+    }
+    /**
+     * @method getLoggerInstance - init/generate new winston logger instance
+     *
+     * @param {LoggerType} logType
+     * @return {*}  {winston.Logger}
+     * @memberof Logger
+     */
+    getLoggerInstance(logType) {
+        const consoleOptions = {
+            format: winston_1.default.format.combine(winston_1.default.format.simple(), winston_1.default.format.colorize({ all: true })),
+        };
+        if (logType === "error") {
+            consoleOptions.level = logType;
+        }
+        if ((0, fs_1.existsSync)(this.config.projectBasePath)) {
+            const filename = (0, path_1.normalize)((0, path_1.join)(this.config.projectBasePath, "logs", `${logType}.log`)).replace(/^(\.\.(\/|\\|$))+/, "");
+            const loggerOptions = {
+                transports: [
+                    new winston_1.default.transports.File(Object.assign(Object.assign({}, this.loggerOptions), { level: logType, filename })),
+                    new winston_1.default.transports.Console(consoleOptions),
+                ],
+                levels: customLevels.levels,
+            };
+            if (logType === "error") {
+                loggerOptions.levels = { error: 0 };
+            }
+            return winston_1.default.createLogger(loggerOptions);
+        }
+        winston_1.default
+            .createLogger({
+            transports: [new winston_1.default.transports.Console(consoleOptions)],
+        })
+            .error("Provided base path is not valid");
+        throw new Error("Provided base path is not valid");
+    }
+    /**
+     * @method log - log/print message with log type (error, info, warn)
+     *
+     * @param {(string | any)} message
+     * @param {(LoggerType | PrintOptions | undefined)} [logType]
+     * @memberof Logger
+     */
+    log(message, logType) {
+        const logString = this.returnString(message);
+        switch (logType) {
+            case "info":
+            case "debug":
+            case "warn":
+                this.infoLogger.log(logType, logString);
+                break;
+            case "error":
+                this.errorLogger.error(logString);
+                break;
+            default:
+                cli_utilities_1.cliux.print(logString, logType || {});
+                break;
+        }
+    }
+    /**
+     * @method returnString - formate error and return as string without any credentials
+     *
+     * @param {*} message
+     * @return {*}  {string}
+     * @memberof Logger
+     */
+    returnString(message) {
+        let returnStr = "";
+        const replaceCredentials = (item) => {
+            try {
+                return JSON.stringify(item).replace(/authtoken":"blt................/g, 'authtoken":"blt....');
+            }
+            catch (error) { }
+            return item;
+        };
+        if (Array.isArray(message) && message.length) {
+            returnStr = (0, map_1.default)(message, (item) => {
+                if (item && typeof item === "object") {
+                    return replaceCredentials(item);
+                }
+                return item;
+            })
+                .join("  ")
+                .trim();
+        }
+        else if ((0, isObject_1.default)(message)) {
+            return replaceCredentials(message);
+        }
+        else {
+            returnStr = message;
+        }
+        returnStr = (0, replace_1.default)(returnStr, new RegExp(ansiRegexPattern, "g"), "").trim();
+        return returnStr;
+    }
+}
+exports.default = Logger;
+/**
+ * @method print - print message on UI
+ *
+ * @export print
+ * @param {Array<PrintType>} printInput
+ */
+function print(printInput) {
+    const str = (0, map_1.default)(printInput, ({ message, bold, color }) => {
+        let chalkFn = chalk_1.default;
+        if (color)
+            chalkFn = chalkFn[color];
+        if (bold)
+            chalkFn = chalkFn.bold;
+        return chalkFn(message);
+    }).join(" ");
+    cli_utilities_1.cliux.print(str);
+}
+exports.print = print;