@contentstack/cli-cm-export 1.5.8 → 1.6.1

package/lib/types/index.js

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

package/lib/utils/basic-login.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+import { ExternalConfig } from '../types';
+declare const login: (config: ExternalConfig) => Promise<any>;
+export default login;

package/lib/utils/basic-login.js

@@ -0,0 +1,45 @@
+"use strict";
+/* eslint-disable max-statements-per-line */
+/* eslint-disable no-console */
+/* eslint-disable no-empty */
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./logger");
+const { managementSDKClient, isAuthenticated, cliux, configHandler, authHandler, } = require('@contentstack/cli-utilities');
+const login = async (config) => {
+    var _a;
+    const client = await managementSDKClient(config);
+    if (config.email && config.password) {
+        const response = await client.login({ email: config.email, password: config.password }).catch(Promise.reject);
+        if ((_a = response === null || response === void 0 ? void 0 : response.user) === null || _a === void 0 ? void 0 : _a.authtoken) {
+            config.headers = {
+                api_key: config.source_stack,
+                access_token: config.access_token,
+                authtoken: response.user.authtoken,
+                'X-User-Agent': 'contentstack-export/v',
+            };
+            await authHandler.setConfigData('basicAuth', response.user);
+            (0, logger_1.log)(config, 'Contentstack account authenticated successfully!', 'success');
+            return config;
+        }
+        else {
+            (0, logger_1.log)(config, 'Failed to login, Invalid credentials', 'error');
+            process.exit(1);
+        }
+    }
+    else if (!config.email && !config.password && config.source_stack && config.access_token) {
+        (0, logger_1.log)(config, 'Content types, entries, assets, labels, global fields, extensions modules will be exported', 'success');
+        (0, logger_1.log)(config, 'Email, password, or management token is not set in the config, cannot export Webhook and label modules', 'success');
+        config.headers = {
+            api_key: config.source_stack,
+            access_token: config.access_token,
+            'X-User-Agent': 'contentstack-export/v',
+        };
+        return config;
+    }
+};
+exports.default = login;

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

@@ -0,0 +1,11 @@
+/*!
+ * Contentstack Export
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+import { ExternalConfig } from '../types';
+export declare const validateConfig: (config: ExternalConfig) => void;
+export declare const formatError: (error: any) => any;
+export declare const executeTask: (tasks: unknown[], handler: (task: unknown) => Promise<unknown>, options: {
+    concurrency: number;
+}) => Promise<unknown[]>;

package/lib/utils/common-helper.js

@@ -0,0 +1,78 @@
+"use strict";
+/*!
+ * Contentstack Export
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTask = exports.formatError = exports.validateConfig = void 0;
+const tslib_1 = require("tslib");
+const promise_limit_1 = tslib_1.__importDefault(require("promise-limit"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const validateConfig = function (config) {
+    if (!config.host || !config.cdn) {
+        throw new Error('Host/CDN end point is missing from config');
+    }
+    if (config.email && config.password && !config.access_token && !config.source_stack) {
+        throw new Error('Kindly provide access_token or api_token');
+    }
+    else if (!config.email &&
+        !config.password &&
+        !config.management_token &&
+        config.source_stack &&
+        !config.access_token &&
+        !(0, cli_utilities_1.isAuthenticated)()) {
+        throw new Error('Kindly provide management_token or email and password');
+    }
+    else if (config.email &&
+        config.password &&
+        !config.access_token &&
+        config.source_stack &&
+        !config.management_token &&
+        !(0, cli_utilities_1.isAuthenticated)()) {
+        throw new Error('Kindly provide access_token or management_token');
+    }
+    else if (!config.email && !config.password && config.preserveStackVersion) {
+        throw new Error('Kindly provide Email and password for stack details');
+    }
+};
+exports.validateConfig = validateConfig;
+const formatError = function (error) {
+    try {
+        if (typeof error === 'string') {
+            error = JSON.parse(error);
+        }
+        else {
+            error = JSON.parse(error.message);
+        }
+    }
+    catch (e) { }
+    let message = error.errorMessage || error.error_message || error.message || error;
+    if (error.errors && Object.keys(error.errors).length > 0) {
+        Object.keys(error.errors).forEach((e) => {
+            let entity = e;
+            if (e === 'authorization')
+                entity = 'Management Token';
+            if (e === 'api_key')
+                entity = 'Stack API key';
+            if (e === 'uid')
+                entity = 'Content Type';
+            if (e === 'access_token')
+                entity = 'Delivery Token';
+            message += ' ' + [entity, error.errors[e]].join(' ');
+        });
+    }
+    return message;
+};
+exports.formatError = formatError;
+const executeTask = function (tasks = [], handler, options) {
+    if (typeof handler !== 'function') {
+        throw new Error('Invalid handler');
+    }
+    const { concurrency = 1 } = options;
+    const limit = (0, promise_limit_1.default)(concurrency);
+    return Promise.all(tasks.map((task) => {
+        return limit(() => handler(task));
+    }));
+};
+exports.executeTask = executeTask;

package/lib/utils/export-config-handler.d.ts

@@ -0,0 +1,3 @@
+import { ExportConfig } from '../types';
+declare const setupConfig: (exportCmdFlags: any) => Promise<ExportConfig>;
+export default setupConfig;

package/lib/utils/export-config-handler.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const merge_1 = tslib_1.__importDefault(require("merge"));
+const path = tslib_1.__importStar(require("path"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const config_1 = tslib_1.__importDefault(require("../config"));
+const file_helper_1 = require("./file-helper");
+const interactive_1 = require("./interactive");
+const basic_login_1 = tslib_1.__importDefault(require("./basic-login"));
+const lodash_1 = require("lodash");
+const setupConfig = async (exportCmdFlags) => {
+    let config = (0, merge_1.default)({}, config_1.default);
+    // setup the config
+    if (exportCmdFlags['config']) {
+        const externalConfig = await (0, file_helper_1.readFile)(exportCmdFlags['config']);
+        config = merge_1.default.recursive(config, externalConfig);
+    }
+    config.exportDir = exportCmdFlags['data'] || exportCmdFlags['data-dir'] || config.data || (await (0, interactive_1.askExportDir)());
+    config.exportDir = path.resolve(config.exportDir);
+    //Note to support the old key
+    config.data = config.exportDir;
+    const managementTokenAlias = exportCmdFlags['management-token-alias'] || exportCmdFlags['alias'];
+    if (managementTokenAlias) {
+        const { token, apiKey } = cli_utilities_1.configHandler.get(`tokens.${managementTokenAlias}`);
+        config.management_token = token;
+        config.apiKey = apiKey;
+        if (!config.management_token) {
+            throw new Error(`No management token found on given alias ${managementTokenAlias}`);
+        }
+    }
+    if (!config.management_token) {
+        if (!(0, cli_utilities_1.isAuthenticated)()) {
+            if (config.username && config.password) {
+                await (0, basic_login_1.default)(config);
+            }
+            else {
+                throw new Error('Please login or provide an alias for the management token');
+            }
+        }
+        else {
+            config.apiKey =
+                exportCmdFlags['stack-uid'] || exportCmdFlags['stack-api-key'] || config.source_stack || (await (0, interactive_1.askAPIKey)());
+            if (typeof config.apiKey !== 'string') {
+                throw new Error('Invalid API key received');
+            }
+        }
+    }
+    // Note support old config
+    config.source_stack = config.apiKey;
+    config.forceStopMarketplaceAppsPrompt = exportCmdFlags.yes;
+    config.auth_token = cli_utilities_1.configHandler.get('authtoken'); // TBD remove once dependent modules are updated
+    config.isAuthenticated = (0, cli_utilities_1.isAuthenticated)();
+    if (exportCmdFlags['branch']) {
+        config.branchName = exportCmdFlags['branch'];
+    }
+    if (exportCmdFlags['module']) {
+        config.moduleName = exportCmdFlags['module'];
+        config.singleModuleExport = true;
+    }
+    if (exportCmdFlags['secured-assets']) {
+        config.securedAssets = true;
+    }
+    if (Array.isArray(exportCmdFlags['content-types']) && exportCmdFlags['content-types'].length > 0) {
+        config.contentTypes = exportCmdFlags['content-types'];
+    }
+    if (Array.isArray(config.filteredModules) && config.filteredModules.length > 0) {
+        config.modules.types = (0, lodash_1.filter)(config_1.default.modules.types, (module) => (0, lodash_1.includes)(config.filteredModules, module));
+    }
+    return config;
+};
+exports.default = setupConfig;

package/lib/utils/file-helper.d.ts

@@ -0,0 +1,14 @@
+import { FsUtility } from '@contentstack/cli-utilities';
+export declare const readFileSync: (filePath: string, parse: boolean) => unknown;
+export declare const readFile: (filePath: string, options?: {
+    type: string;
+}) => Promise<any>;
+export declare const readLargeFile: (filePath: string, options?: {
+    type?: string;
+}) => Promise<any>;
+export declare const writeFileSync: (filePath: string, data: any) => void;
+export declare const writeFile: (filePath: string, data: any) => Promise<any>;
+export declare const writeLargeFile: (filePath: string, data: any) => Promise<any>;
+export declare const makeDirectory: (dir: string) => void;
+export declare const readdir: (dirPath: string) => any;
+export declare const fsUtil: FsUtility;

package/lib/utils/file-helper.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fsUtil = exports.readdir = exports.makeDirectory = exports.writeLargeFile = exports.writeFile = exports.writeFileSync = exports.readLargeFile = exports.readFile = exports.readFileSync = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const mkdirp_1 = tslib_1.__importDefault(require("mkdirp"));
+const big_json_1 = tslib_1.__importDefault(require("big-json"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const readFileSync = function (filePath, parse) {
+    let data;
+    parse = typeof parse === 'undefined' ? true : parse;
+    filePath = path.resolve(filePath);
+    if (fs.existsSync(filePath)) {
+        data = parse ? JSON.parse(fs.readFileSync(filePath, 'utf8')) : data;
+    }
+    return data;
+};
+exports.readFileSync = readFileSync;
+// by default file type is json
+const readFile = async (filePath, options = { type: 'json' }) => {
+    return new Promise((resolve, reject) => {
+        filePath = path.resolve(filePath);
+        fs.readFile(filePath, 'utf-8', (error, data) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                if (options.type !== 'json') {
+                    return resolve(data);
+                }
+                resolve(JSON.parse(data));
+            }
+        });
+    });
+};
+exports.readFile = readFile;
+const readLargeFile = function (filePath, options = {}) {
+    if (typeof filePath !== 'string') {
+        return;
+    }
+    filePath = path.resolve(filePath);
+    if (fs.existsSync(filePath)) {
+        return new Promise((resolve, reject) => {
+            const readStream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+            const parseStream = big_json_1.default.createParseStream();
+            parseStream.on('data', function (data) {
+                if (options.type === 'array') {
+                    return resolve(Object.values(data));
+                }
+                resolve(data);
+            });
+            parseStream.on('error', (error) => {
+                console.log('error', error);
+                reject(error);
+            });
+            readStream.pipe(parseStream);
+        });
+    }
+};
+exports.readLargeFile = readLargeFile;
+const writeFileSync = function (filePath, data) {
+    data = typeof data === 'object' ? JSON.stringify(data) : data || '{}';
+    fs.writeFileSync(filePath, data);
+};
+exports.writeFileSync = writeFileSync;
+const writeFile = function (filePath, data) {
+    return new Promise((resolve, reject) => {
+        data = typeof data === 'object' ? JSON.stringify(data) : data || '{}';
+        fs.writeFile(filePath, data, (error) => {
+            if (error) {
+                return reject(error);
+            }
+            resolve('done');
+        });
+    });
+};
+exports.writeFile = writeFile;
+const writeLargeFile = function (filePath, data) {
+    if (typeof filePath !== 'string' || typeof data !== 'object') {
+        return;
+    }
+    filePath = path.resolve(filePath);
+    return new Promise((resolve, reject) => {
+        const stringifyStream = big_json_1.default.createStringifyStream({
+            body: data,
+        });
+        var writeStream = fs.createWriteStream(filePath, 'utf-8');
+        stringifyStream.pipe(writeStream);
+        writeStream.on('finish', () => {
+            resolve('');
+        });
+        writeStream.on('error', (error) => {
+            reject(error);
+        });
+    });
+};
+exports.writeLargeFile = writeLargeFile;
+const makeDirectory = function (dir) {
+    for (const key in arguments) {
+        const dirname = path.resolve(arguments[key]);
+        if (!fs.existsSync(dirname)) {
+            mkdirp_1.default.sync(dirname);
+        }
+    }
+};
+exports.makeDirectory = makeDirectory;
+const readdir = function (dirPath) {
+    if (fs.existsSync(dirPath)) {
+        return fs.readdirSync(dirPath);
+    }
+    else {
+        return [];
+    }
+};
+exports.readdir = readdir;
+exports.fileExistsSync = function (path) {
+    return fs.existsSync(path);
+};
+exports.fsUtil = new cli_utilities_1.FsUtility();

package/lib/utils/index.d.ts

@@ -0,0 +1,10 @@
+export * as interactive from './interactive';
+export { default as setupExportConfig } from './export-config-handler';
+export * as fileHelper from './file-helper';
+export { fsUtil } from './file-helper';
+export { default as setupBranches } from './setup-branches';
+export { default as setupExportDir } from './setup-export-dir';
+export { log, unlinkFileLogger } from './logger';
+export { default as login } from './basic-login';
+export * from './common-helper';
+export * from './marketplace-app-helper';

package/lib/utils/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = exports.unlinkFileLogger = exports.log = exports.setupExportDir = exports.setupBranches = exports.fsUtil = exports.fileHelper = exports.setupExportConfig = exports.interactive = void 0;
+const tslib_1 = require("tslib");
+exports.interactive = tslib_1.__importStar(require("./interactive"));
+var export_config_handler_1 = require("./export-config-handler");
+Object.defineProperty(exports, "setupExportConfig", { enumerable: true, get: function () { return tslib_1.__importDefault(export_config_handler_1).default; } });
+exports.fileHelper = tslib_1.__importStar(require("./file-helper"));
+var file_helper_1 = require("./file-helper");
+Object.defineProperty(exports, "fsUtil", { enumerable: true, get: function () { return file_helper_1.fsUtil; } });
+var setup_branches_1 = require("./setup-branches");
+Object.defineProperty(exports, "setupBranches", { enumerable: true, get: function () { return tslib_1.__importDefault(setup_branches_1).default; } });
+var setup_export_dir_1 = require("./setup-export-dir");
+Object.defineProperty(exports, "setupExportDir", { enumerable: true, get: function () { return tslib_1.__importDefault(setup_export_dir_1).default; } });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "log", { enumerable: true, get: function () { return logger_1.log; } });
+Object.defineProperty(exports, "unlinkFileLogger", { enumerable: true, get: function () { return logger_1.unlinkFileLogger; } });
+var basic_login_1 = require("./basic-login");
+Object.defineProperty(exports, "login", { enumerable: true, get: function () { return tslib_1.__importDefault(basic_login_1).default; } });
+tslib_1.__exportStar(require("./common-helper"), exports);
+tslib_1.__exportStar(require("./marketplace-app-helper"), exports);

package/lib/utils/interactive.d.ts

@@ -0,0 +1,6 @@
+export declare const askPassword: () => Promise<string>;
+export declare const askOTPChannel: () => Promise<string>;
+export declare const askOTP: () => Promise<string>;
+export declare const askUsername: () => Promise<string>;
+export declare const askExportDir: () => Promise<string>;
+export declare const askAPIKey: () => Promise<string>;

package/lib/utils/interactive.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askAPIKey = exports.askExportDir = exports.askUsername = exports.askOTP = exports.askOTPChannel = exports.askPassword = void 0;
+const tslib_1 = require("tslib");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const path = tslib_1.__importStar(require("path"));
+const askPassword = async () => {
+    return cli_utilities_1.cliux.inquire({
+        type: 'input',
+        message: 'CLI_AUTH_LOGIN_ENTER_PASSWORD',
+        name: 'password',
+        transformer: (pswd) => {
+            let pswdMasked = '';
+            for (let i = 0; i < pswd.length; i++) {
+                pswdMasked += '*';
+            }
+            return pswdMasked;
+        },
+    });
+};
+exports.askPassword = askPassword;
+const askOTPChannel = async () => {
+    return cli_utilities_1.cliux.inquire({
+        type: 'list',
+        name: 'otpChannel',
+        message: 'CLI_AUTH_LOGIN_ASK_CHANNEL_FOR_OTP',
+        choices: [
+            { name: 'Authy App', value: 'authy' },
+            { name: 'SMS', value: 'sms' },
+        ],
+    });
+};
+exports.askOTPChannel = askOTPChannel;
+const askOTP = async () => {
+    return cli_utilities_1.cliux.inquire({
+        type: 'input',
+        message: 'CLI_AUTH_LOGIN_ENTER_SECURITY_CODE',
+        name: 'tfaToken',
+    });
+};
+exports.askOTP = askOTP;
+const askUsername = async () => {
+    return cli_utilities_1.cliux.inquire({
+        type: 'input',
+        message: 'CLI_AUTH_LOGIN_ENTER_EMAIL_ADDRESS',
+        name: 'username',
+    });
+};
+exports.askUsername = askUsername;
+const askExportDir = async () => {
+    const result = await cli_utilities_1.cliux.inquire({
+        type: 'input',
+        message: 'Enter the path for storing the content: (current folder)',
+        name: 'dir',
+    });
+    if (!result) {
+        return process.cwd();
+    }
+    else {
+        return path.resolve(result);
+    }
+};
+exports.askExportDir = askExportDir;
+const askAPIKey = async () => {
+    return cli_utilities_1.cliux.inquire({
+        type: 'input',
+        message: 'Enter the stack api key',
+        name: 'apiKey',
+    });
+};
+exports.askAPIKey = askAPIKey;

package/lib/utils/logger.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Contentstack Export
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+import { ExportConfig } from '../types';
+export declare const log: (config: ExportConfig, message: any, type: string) => Promise<void>;
+export declare const unlinkFileLogger: () => void;

package/lib/utils/logger.js

@@ -0,0 +1,154 @@
+"use strict";
+/*!
+ * Contentstack Export
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unlinkFileLogger = exports.log = void 0;
+const tslib_1 = require("tslib");
+const winston = tslib_1.__importStar(require("winston"));
+const path = tslib_1.__importStar(require("path"));
+const mkdirp_1 = tslib_1.__importDefault(require("mkdirp"));
+const slice = Array.prototype.slice;
+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('|');
+function returnString(args) {
+    let returnStr = '';
+    if (args && args.length) {
+        returnStr = args
+            .map(function (item) {
+            if (item && typeof item === 'object') {
+                try {
+                    return JSON.stringify(item).replace(/authtoken\":\d"blt................/g, 'authtoken":"blt....');
+                }
+                catch (error) { }
+                return item;
+            }
+            return item;
+        })
+            .join('  ')
+            .trim();
+    }
+    returnStr = returnStr.replace(new RegExp(ansiRegexPattern, 'g'), '').trim();
+    return returnStr;
+}
+const myCustomLevels = {
+    levels: {
+        warn: 1,
+        info: 2,
+        debug: 3,
+    },
+    colors: {
+        //colors aren't being used anywhere as of now, we're using chalk to add colors while logging
+        info: 'blue',
+        debug: 'green',
+        warn: 'yellow',
+        error: 'red',
+    },
+};
+let logger;
+let errorLogger;
+let successTransport;
+let errorTransport;
+function init(_logPath) {
+    if (!logger || !errorLogger) {
+        const logsDir = path.resolve(_logPath, 'logs', 'export');
+        // Create dir if doesn't already exist
+        mkdirp_1.default.sync(logsDir);
+        successTransport = {
+            filename: path.join(logsDir, 'success.log'),
+            maxFiles: 20,
+            maxsize: 1000000,
+            tailable: true,
+            level: 'info',
+        };
+        errorTransport = {
+            filename: path.join(logsDir, 'error.log'),
+            maxFiles: 20,
+            maxsize: 1000000,
+            tailable: true,
+            level: 'error',
+        };
+        logger = winston.createLogger({
+            transports: [
+                new winston.transports.File(successTransport),
+                new winston.transports.Console({ format: winston.format.simple() }),
+            ],
+            levels: myCustomLevels.levels,
+        });
+        errorLogger = winston.createLogger({
+            transports: [
+                new winston.transports.File(errorTransport),
+                new winston.transports.Console({
+                    level: 'error',
+                    format: winston.format.combine(winston.format.colorize({ all: true, colors: { error: 'red' } }), winston.format.simple()),
+                }),
+            ],
+            levels: { error: 0 },
+        });
+    }
+    return {
+        log: function (message) {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                logger.log('info', logString);
+            }
+        },
+        warn: function () {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                logger.log('warn', logString);
+            }
+        },
+        error: function (message) {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                errorLogger.log('error', logString);
+            }
+        },
+        debug: function () {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                logger.log('debug', logString);
+            }
+        },
+    };
+}
+const log = async (config, message, type) => {
+    config.data = config.data || path.join(__dirname, 'logs');
+    // ignoring the type argument, as we are not using it to create a logfile anymore
+    if (type !== 'error') {
+        // removed type argument from init method
+        init(config.data).log(message);
+    }
+    else {
+        init(config.data).error(message);
+    }
+};
+exports.log = log;
+const unlinkFileLogger = () => {
+    if (logger) {
+        const transports = logger.transports;
+        transports.forEach((transport) => {
+            if (transport.name === 'file') {
+                logger.remove(transport);
+            }
+        });
+    }
+    if (errorLogger) {
+        const transports = errorLogger.transports;
+        transports.forEach((transport) => {
+            if (transport.name === 'file') {
+                errorLogger.remove(transport);
+            }
+        });
+    }
+};
+exports.unlinkFileLogger = unlinkFileLogger;

package/lib/utils/marketplace-app-helper.d.ts

@@ -0,0 +1 @@
+export declare const getDeveloperHubUrl: () => Promise<any>;

package/lib/utils/marketplace-app-helper.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeveloperHubUrl = void 0;
+let { default: config } = require('../config');
+const { cliux, configHandler } = require('@contentstack/cli-utilities');
+const getDeveloperHubUrl = async () => {
+    const { cma, name } = configHandler.get('region') || {};
+    let developerHubBaseUrl = config.developerHubUrls[cma];
+    if (!developerHubBaseUrl) {
+        developerHubBaseUrl = await cliux.inquire({
+            type: 'input',
+            name: 'name',
+            validate: (url) => {
+                if (!url)
+                    return "Developer-hub URL can't be empty.";
+                return true;
+            },
+            message: `Enter the developer-hub base URL for the ${name} region - `,
+        });
+    }
+    return developerHubBaseUrl.startsWith('http') ? developerHubBaseUrl : `https://${developerHubBaseUrl}`;
+};
+exports.getDeveloperHubUrl = getDeveloperHubUrl;

package/lib/utils/setup-branches.d.ts

@@ -0,0 +1,3 @@
+import { ExportConfig } from 'src/types';
+declare const setupBranches: (config: ExportConfig, stackAPIClient: any) => Promise<void>;
+export default setupBranches;