@contentstack/cli-cm-import 1.5.10 → 1.6.0

package/lib/utils/entries-helper.js

@@ -0,0 +1,252 @@
+"use strict";
+/**
+ * Entries lookup
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupEntries = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const _ = tslib_1.__importStar(require("lodash"));
+const config_1 = tslib_1.__importDefault(require("../config"));
+const fileHelper = tslib_1.__importStar(require("./file-helper"));
+// update references in entry object
+const lookupEntries = function (data, mappedUids, uidMapperPath) {
+    let parent = [];
+    let uids = [];
+    let unmapped = [];
+    let mapped = [];
+    let isNewRefFields = false;
+    let preserveStackVersion = config_1.default.preserveStackVersion;
+    function gatherJsonRteEntryIds(jsonRteData) {
+        jsonRteData.children.forEach((element) => {
+            if (element.type) {
+                switch (element.type) {
+                    case 'a':
+                    case 'p': {
+                        if (element.children && element.children.length > 0) {
+                            gatherJsonRteEntryIds(element);
+                        }
+                        break;
+                    }
+                    case 'reference': {
+                        if (Object.keys(element.attrs).length > 0 && element.attrs.type === 'entry') {
+                            if (uids.indexOf(element.attrs['entry-uid']) === -1) {
+                                uids.push(element.attrs['entry-uid']);
+                            }
+                        }
+                        if (element.children && element.children.length > 0) {
+                            gatherJsonRteEntryIds(element);
+                        }
+                        break;
+                    }
+                }
+            }
+        });
+    }
+    const update = function (_parent, form_id, updateEntry) {
+        let _entry = updateEntry;
+        let len = _parent.length;
+        for (let j = 0; j < len; j++) {
+            if (_entry && _parent[j]) {
+                if (j === len - 1 && _entry[_parent[j]]) {
+                    if (form_id !== '_assets') {
+                        if (_entry[_parent[j]].length) {
+                            _entry[_parent[j]].forEach((item, idx) => {
+                                if (typeof item.uid === 'string' && item._content_type_uid) {
+                                    uids.push(item.uid);
+                                }
+                                else if (typeof item === 'string' && preserveStackVersion === true) {
+                                    uids.push(item);
+                                }
+                                else {
+                                    uids.push(item);
+                                    _entry[_parent[j]][idx] = {
+                                        uid: item,
+                                        _content_type_uid: form_id,
+                                    };
+                                }
+                            });
+                        }
+                    }
+                    else if (Array.isArray(_entry[_parent[j]])) {
+                        for (const element of _entry[_parent[j]]) {
+                            if (element.uid.length) {
+                                uids.push(element.uid);
+                            }
+                        }
+                    }
+                    else if (_entry[_parent[j]].uid.length) {
+                        uids.push(_entry[_parent[j]].uid);
+                    }
+                }
+                else {
+                    _entry = _entry[_parent[j]];
+                    let _keys = _.clone(_parent).splice(j + 1, len);
+                    if (Array.isArray(_entry)) {
+                        for (let i = 0, _i = _entry.length; i < _i; i++) {
+                            update(_keys, form_id, _entry[i]);
+                        }
+                    }
+                    else if (!(_entry instanceof Object)) {
+                        break;
+                    }
+                }
+            }
+        }
+    };
+    const find = function (schema, _entry) {
+        for (let i = 0, _i = schema.length; i < _i; i++) {
+            switch (schema[i].data_type) {
+                case 'reference':
+                    if (Array.isArray(schema[i].reference_to)) {
+                        isNewRefFields = true;
+                        schema[i].reference_to.forEach((reference) => {
+                            parent.push(schema[i].uid);
+                            update(parent, reference, _entry);
+                            parent.pop();
+                        });
+                    }
+                    else {
+                        parent.push(schema[i].uid);
+                        update(parent, schema[i].reference_to, _entry);
+                        parent.pop();
+                    }
+                    break;
+                case 'global_field':
+                case 'group':
+                    parent.push(schema[i].uid);
+                    find(schema[i].schema, _entry);
+                    parent.pop();
+                    break;
+                case 'blocks':
+                    for (let j = 0, _j = schema[i].blocks.length; j < _j; j++) {
+                        parent.push(schema[i].uid);
+                        parent.push(schema[i].blocks[j].uid);
+                        find(schema[i].blocks[j].schema, _entry);
+                        parent.pop();
+                        parent.pop();
+                    }
+                    break;
+                case 'json':
+                    if (schema[i].field_metadata.rich_text_type) {
+                        findEntryIdsFromJsonRte(data.entry, data.content_type.schema);
+                    }
+                    break;
+            }
+        }
+    };
+    function findEntryIdsFromJsonRte(entry, ctSchema) {
+        for (const element of ctSchema) {
+            switch (element.data_type) {
+                case 'blocks': {
+                    if (entry[element.uid]) {
+                        if (element.multiple) {
+                            entry[element.uid].forEach((e) => {
+                                let key = Object.keys(e).pop();
+                                let subBlock = element.blocks.filter((e) => e.uid === key).pop();
+                                findEntryIdsFromJsonRte(e[key], subBlock.schema);
+                            });
+                        }
+                    }
+                    break;
+                }
+                case 'global_field':
+                case 'group': {
+                    if (entry[element.uid]) {
+                        if (element.multiple) {
+                            entry[element.uid].forEach((e) => {
+                                findEntryIdsFromJsonRte(e, element.schema);
+                            });
+                        }
+                        else {
+                            findEntryIdsFromJsonRte(entry[element.uid], element.schema);
+                        }
+                    }
+                    break;
+                }
+                case 'json': {
+                    if (entry[element.uid] && element.field_metadata.rich_text_type) {
+                        if (element.multiple) {
+                            entry[element.uid].forEach((jsonRteData) => {
+                                gatherJsonRteEntryIds(jsonRteData);
+                            });
+                        }
+                        else {
+                            gatherJsonRteEntryIds(entry[element.uid]);
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    find(data.content_type.schema, data.entry);
+    if (isNewRefFields) {
+        findUidsInNewRefFields(data.entry, uids);
+    }
+    uids = _.flattenDeep(uids);
+    // if no references are found, return
+    if (uids.length === 0) {
+        return data.entry;
+    }
+    uids = _.uniq(uids);
+    let entry = JSON.stringify(data.entry);
+    uids.forEach(function (uid) {
+        if (mappedUids.hasOwnProperty(uid)) {
+            entry = entry.replace(new RegExp(uid, 'img'), mappedUids[uid]);
+            mapped.push(uid);
+        }
+        else {
+            unmapped.push(uid);
+        }
+    });
+    if (unmapped.length > 0) {
+        let unmappedUids = fileHelper.readFileSync(path.join(uidMapperPath, 'unmapped-uids.json'));
+        unmappedUids = unmappedUids || {};
+        if (unmappedUids.hasOwnProperty(data.content_type.uid)) {
+            unmappedUids[data.content_type.uid][data.entry.uid] = unmapped;
+        }
+        else {
+            unmappedUids[data.content_type.uid] = {
+                [data.entry.uid]: unmapped,
+            };
+        }
+        // write the unmapped contents to ./mapper/language/unmapped-uids.json
+        fileHelper.writeFile(path.join(uidMapperPath, 'unmapped-uids.json'), unmappedUids);
+    }
+    if (mapped.length > 0) {
+        let _mappedUids = fileHelper.readFileSync(path.join(uidMapperPath, 'mapped-uids.json'));
+        _mappedUids = _mappedUids || {};
+        if (_mappedUids.hasOwnProperty(data.content_type.uid)) {
+            _mappedUids[data.content_type.uid][data.entry.uid] = mapped;
+        }
+        else {
+            _mappedUids[data.content_type.uid] = {
+                [data.entry.uid]: mapped,
+            };
+        }
+        // write the mapped contents to ./mapper/language/mapped-uids.json
+        fileHelper.writeFile(path.join(uidMapperPath, 'mapped-uids.json'), _mappedUids);
+    }
+    return JSON.parse(entry);
+};
+exports.lookupEntries = lookupEntries;
+function findUidsInNewRefFields(entry, uids) {
+    if (entry && typeof entry === 'object') {
+        if (entry.uid && entry._content_type_uid) {
+            uids.push(entry.uid);
+        }
+        else if (Array.isArray(entry) && entry.length) {
+            entry.forEach(function (elem) {
+                findUidsInNewRefFields(elem, uids);
+            });
+        }
+        else if (Object.keys(entry).length) {
+            for (let key in entry) {
+                if (key) {
+                    findUidsInNewRefFields(entry[key], uids);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+/**
+ * extension lookup
+ */
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+import { ImportConfig } from '../types';
+export declare const lookupExtension: (config: ImportConfig, schema: any, preserveStackVersion: any, installedExtensions: any) => void;

package/lib/utils/extension-helper.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * extension lookup
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupExtension = void 0;
+// eslint-disable-next-line unicorn/filename-case
+let path = require('path');
+const _ = require('lodash');
+let helper = require('./file-helper');
+// eslint-disable-next-line camelcase
+const lookupExtension = function (config, schema, preserveStackVersion, installedExtensions) {
+    const extensionPath = path.resolve(config.data, 'mapper/extensions', 'uid-mapping.json');
+    const globalfieldsPath = path.resolve(config.data, 'mapper/globalfields', 'uid-mapping.json');
+    const marketplaceAppPath = path.resolve(config.data, 'marketplace_apps', 'marketplace_apps.json');
+    for (let i in schema) {
+        if (schema[i].data_type === 'group') {
+            (0, exports.lookupExtension)(config, schema[i].schema, preserveStackVersion, installedExtensions);
+        }
+        else if (schema[i].data_type === 'blocks') {
+            for (let block in schema[i].blocks) {
+                if (schema[i].blocks[block].hasOwnProperty('reference_to')) {
+                    delete schema[i].blocks[block].schema;
+                }
+                else {
+                    (0, exports.lookupExtension)(config, schema[i].blocks[block].schema, preserveStackVersion, installedExtensions);
+                }
+            }
+        }
+        else if (schema[i].data_type === 'reference' &&
+            !schema[i].field_metadata.hasOwnProperty('ref_multiple_content_types')) {
+            if (preserveStackVersion) {
+                // do nothing
+            }
+            else {
+                schema[i].reference_to = [schema[i].reference_to];
+                schema[i].field_metadata.ref_multiple_content_types = true;
+            }
+        }
+        else if (schema[i].data_type === 'global_field') {
+            let global_fields_key_value = schema[i].reference_to;
+            let global_fields_data = helper.readFileSync(path.join(globalfieldsPath));
+            if (global_fields_data && global_fields_data.hasOwnProperty(global_fields_key_value)) {
+                schema[i].reference_to = global_fields_data[global_fields_key_value];
+            }
+        }
+        else if (schema[i].hasOwnProperty('extension_uid')) {
+            const extension_key_value = schema[i].extension_uid;
+            const data = helper.readFileSync(path.join(extensionPath));
+            if (data && data.hasOwnProperty(extension_key_value)) {
+                // eslint-disable-next-line camelcase
+                schema[i].extension_uid = data[extension_key_value];
+            }
+            else if (schema[i].field_metadata && schema[i].field_metadata.extension) {
+                if (installedExtensions && installedExtensions[schema[i].extension_uid]) {
+                    schema[i].extension_uid = installedExtensions[schema[i].extension_uid];
+                }
+            }
+        }
+        else if (schema[i].data_type === 'json' && schema[i].hasOwnProperty('plugins') && schema[i].plugins.length > 0) {
+            const newPluginUidsArray = [];
+            const data = helper.readFileSync(path.join(extensionPath));
+            schema[i].plugins.forEach((extension_key_value) => {
+                if (data && data.hasOwnProperty(extension_key_value)) {
+                    newPluginUidsArray.push(data[extension_key_value]);
+                }
+            });
+            schema[i].plugins = newPluginUidsArray;
+        }
+    }
+};
+exports.lookupExtension = lookupExtension;

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) => any;
+export declare const readFile: (filePath: string, options?: {
+    type: string;
+}) => Promise<any>;
+export declare const readLargeFile: (filePath: string, opts?: any) => 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 readdirSync: (dirPath: string) => any;
+export declare const isFolderExist: (folderPath: string) => Promise<any>;
+export declare const fileExistsSync: (path: string) => boolean;
+export declare const fsUtil: FsUtility;

package/lib/utils/file-helper.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fsUtil = exports.fileExistsSync = exports.isFolderExist = exports.readdirSync = 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 bigJSON = tslib_1.__importStar(require("big-json"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const readFileSync = function (filePath, parse = true) {
+    let data;
+    filePath = path.resolve(filePath);
+    if (fs.existsSync(filePath)) {
+        try {
+            data = parse ? JSON.parse(fs.readFileSync(filePath, 'utf-8')) : data;
+        }
+        catch (error) {
+            return 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) {
+                if (error.code === 'ENOENT') {
+                    return resolve('');
+                }
+                reject(error);
+            }
+            else {
+                if (options.type !== 'json') {
+                    return resolve(data);
+                }
+                resolve(JSON.parse(data));
+            }
+        });
+    });
+};
+exports.readFile = readFile;
+const readLargeFile = function (filePath, opts) {
+    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 = bigJSON.createParseStream();
+            parseStream.on('data', function (data) {
+                if ((opts === null || opts === void 0 ? void 0 : opts.type) === 'array') {
+                    return resolve(Object.values(data));
+                }
+                resolve(data);
+            });
+            parseStream.on('error', function (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 = bigJSON.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 (let key in arguments) {
+        const dirname = path.resolve(arguments[key]);
+        if (!fs.existsSync(dirname)) {
+            mkdirp_1.default.sync(dirname);
+        }
+    }
+};
+exports.makeDirectory = makeDirectory;
+const readdirSync = function (dirPath) {
+    if (fs.existsSync(dirPath)) {
+        return fs.readdirSync(dirPath);
+    }
+    else {
+        return [];
+    }
+};
+exports.readdirSync = readdirSync;
+const isFolderExist = async (folderPath) => {
+    return new Promise((resolve, reject) => {
+        folderPath = path.resolve(folderPath);
+        fs.access(folderPath, (error) => {
+            if (error) {
+                return resolve(false);
+            }
+            resolve(true);
+        });
+    });
+};
+exports.isFolderExist = isFolderExist;
+const fileExistsSync = function (path) {
+    return fs.existsSync(path);
+};
+exports.fileExistsSync = fileExistsSync;
+exports.fsUtil = new cli_utilities_1.FsUtility();

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

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

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

@@ -0,0 +1,73 @@
+"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 lodash_1 = require("lodash");
+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 login_handler_1 = tslib_1.__importDefault(require("./login-handler"));
+const setupConfig = async (importCmdFlags) => {
+    let config = (0, merge_1.default)({}, config_1.default);
+    // setup the config
+    if (importCmdFlags['config']) {
+        let externalConfig = await (0, file_helper_1.readFile)(importCmdFlags['config']);
+        if ((0, lodash_1.isArray)(externalConfig['modules'])) {
+            config.modules.types = (0, lodash_1.filter)(config.modules.types, (module) => (0, lodash_1.includes)(externalConfig['modules'], module));
+            externalConfig = (0, lodash_1.omit)(externalConfig, ['modules']);
+        }
+        config = merge_1.default.recursive(config, externalConfig);
+    }
+    config.contentDir = importCmdFlags['data'] || importCmdFlags['data-dir'] || config.data || (await (0, interactive_1.askContentDir)());
+    config.contentDir = path.resolve(config.contentDir);
+    //Note to support the old key
+    config.data = config.contentDir;
+    const managementTokenAlias = importCmdFlags['management-token-alias'] || importCmdFlags['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.email && config.password) {
+                await (0, login_handler_1.default)(config);
+            }
+            else {
+                throw new Error('Please login or provide an alias for the management token');
+            }
+        }
+        else {
+            config.apiKey =
+                importCmdFlags['stack-uid'] || importCmdFlags['stack-api-key'] || config.target_stack || (await (0, interactive_1.askAPIKey)());
+            if (typeof config.apiKey !== 'string') {
+                throw new Error('Invalid API key received');
+            }
+        }
+    }
+    config.isAuthenticated = (0, cli_utilities_1.isAuthenticated)();
+    //Note to support the old key
+    config.source_stack = config.apiKey;
+    config.importWebhookStatus = importCmdFlags.importWebhookStatus;
+    config.forceStopMarketplaceAppsPrompt = importCmdFlags.yes;
+    if (importCmdFlags['branch']) {
+        config.branchName = importCmdFlags['branch'];
+        config.branchDir = path.join(config.contentDir, config.branchName);
+    }
+    if (importCmdFlags['module']) {
+        config.moduleName = importCmdFlags['module'];
+        config.singleModuleImport = true;
+    }
+    if (importCmdFlags['backup-dir']) {
+        config.useBackedupDir = importCmdFlags['backup-dir'];
+    }
+    // Note to support old modules
+    config.target_stack = config.apiKey;
+    return config;
+};
+exports.default = setupConfig;

package/lib/utils/index.d.ts

@@ -0,0 +1,12 @@
+export * as interactive from './interactive';
+export { default as setupImportConfig } from './import-config-handler';
+export * as fileHelper from './file-helper';
+export { fsUtil } from './file-helper';
+export { default as backupHandler } from './backup-handler';
+export { log, unlinkFileLogger } from './logger';
+export { uploadAssetHelper, lookupAssets } from './asset-helper';
+export { getDeveloperHubUrl } from './marketplace-app-helper';
+export { schemaTemplate, suppressSchemaReference, removeReferenceFields } from './content-type-helper';
+export { lookupExtension } from './extension-helper';
+export { lookupEntries } from './entries-helper';
+export * from './common-helper';

package/lib/utils/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupEntries = exports.lookupExtension = exports.removeReferenceFields = exports.suppressSchemaReference = exports.schemaTemplate = exports.getDeveloperHubUrl = exports.lookupAssets = exports.uploadAssetHelper = exports.unlinkFileLogger = exports.log = exports.backupHandler = exports.fsUtil = exports.fileHelper = exports.setupImportConfig = exports.interactive = void 0;
+const tslib_1 = require("tslib");
+exports.interactive = tslib_1.__importStar(require("./interactive"));
+var import_config_handler_1 = require("./import-config-handler");
+Object.defineProperty(exports, "setupImportConfig", { enumerable: true, get: function () { return tslib_1.__importDefault(import_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 backup_handler_1 = require("./backup-handler");
+Object.defineProperty(exports, "backupHandler", { enumerable: true, get: function () { return tslib_1.__importDefault(backup_handler_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 asset_helper_1 = require("./asset-helper");
+Object.defineProperty(exports, "uploadAssetHelper", { enumerable: true, get: function () { return asset_helper_1.uploadAssetHelper; } });
+Object.defineProperty(exports, "lookupAssets", { enumerable: true, get: function () { return asset_helper_1.lookupAssets; } });
+var marketplace_app_helper_1 = require("./marketplace-app-helper");
+Object.defineProperty(exports, "getDeveloperHubUrl", { enumerable: true, get: function () { return marketplace_app_helper_1.getDeveloperHubUrl; } });
+var content_type_helper_1 = require("./content-type-helper");
+Object.defineProperty(exports, "schemaTemplate", { enumerable: true, get: function () { return content_type_helper_1.schemaTemplate; } });
+Object.defineProperty(exports, "suppressSchemaReference", { enumerable: true, get: function () { return content_type_helper_1.suppressSchemaReference; } });
+Object.defineProperty(exports, "removeReferenceFields", { enumerable: true, get: function () { return content_type_helper_1.removeReferenceFields; } });
+var extension_helper_1 = require("./extension-helper");
+Object.defineProperty(exports, "lookupExtension", { enumerable: true, get: function () { return extension_helper_1.lookupExtension; } });
+var entries_helper_1 = require("./entries-helper");
+Object.defineProperty(exports, "lookupEntries", { enumerable: true, get: function () { return entries_helper_1.lookupEntries; } });
+tslib_1.__exportStar(require("./common-helper"), exports);

package/lib/utils/interactive.d.ts

@@ -0,0 +1,2 @@
+export declare const askContentDir: () => Promise<string>;
+export declare const askAPIKey: () => Promise<string>;

package/lib/utils/interactive.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askAPIKey = exports.askContentDir = void 0;
+const tslib_1 = require("tslib");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const path = tslib_1.__importStar(require("path"));
+const askContentDir = async () => {
+    const result = await cli_utilities_1.cliux.inquire({
+        type: 'input',
+        message: 'Enter the path for the content',
+        name: 'dir',
+    });
+    return path.resolve(result);
+};
+exports.askContentDir = askContentDir;
+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 { ImportConfig } from '../types';
+export declare const log: (config: ImportConfig, message: any, type: string) => Promise<void>;
+export declare const unlinkFileLogger: () => void;