@contentstack/cli-cm-import 1.5.11 → 1.7.0

package/lib/import/modules/environments.d.ts

@@ -0,0 +1,27 @@
+import BaseClass, { ApiOptions } from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class ImportEnvironments extends BaseClass {
+    private mapperDirPath;
+    private environmentsFolderPath;
+    private envUidMapperPath;
+    private envSuccessPath;
+    private envFailsPath;
+    private environmentsConfig;
+    private environments;
+    private envUidMapper;
+    private envSuccess;
+    private envFailed;
+    constructor({ importConfig, stackAPIClient }: ModuleClassParams);
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    start(): Promise<void>;
+    importEnvironments(): Promise<string>;
+    /**
+     * @method serializeEnvironments
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeEnvironments(apiOptions: ApiOptions): ApiOptions;
+}

package/lib/import/modules/environments.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const values_1 = tslib_1.__importDefault(require("lodash/values"));
+const node_path_1 = require("node:path");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class ImportEnvironments extends base_class_1.default {
+    constructor({ importConfig, stackAPIClient }) {
+        super({ importConfig, stackAPIClient });
+        this.environmentsConfig = config_1.default.modules.environments;
+        this.mapperDirPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'environments');
+        this.environmentsFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, this.environmentsConfig.dirName);
+        this.envUidMapperPath = (0, node_path_1.join)(this.mapperDirPath, 'uid-mapping.json');
+        this.envSuccessPath = (0, node_path_1.join)(this.mapperDirPath, 'success.json');
+        this.envFailsPath = (0, node_path_1.join)(this.mapperDirPath, 'fails.json');
+        this.envFailed = [];
+        this.envSuccess = [];
+        this.envUidMapper = {};
+    }
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    async start() {
+        var _a, _b;
+        (0, utils_1.log)(this.importConfig, 'Migrating environments', 'info');
+        //Step1 check folder exists or not
+        if (utils_1.fileHelper.fileExistsSync(this.environmentsFolderPath)) {
+            this.environments = utils_1.fsUtil.readFile((0, node_path_1.join)(this.environmentsFolderPath, 'environments.json'), true);
+        }
+        else {
+            (0, utils_1.log)(this.importConfig, `No such file or directory - '${this.environmentsFolderPath}'`, 'error');
+            return;
+        }
+        await utils_1.fsUtil.makeDirectory(this.mapperDirPath);
+        this.envUidMapper = utils_1.fileHelper.fileExistsSync(this.envUidMapperPath)
+            ? utils_1.fsUtil.readFile((0, node_path_1.join)(this.envUidMapperPath), true)
+            : {};
+        await this.importEnvironments();
+        if ((_a = this.envSuccess) === null || _a === void 0 ? void 0 : _a.length) {
+            utils_1.fsUtil.writeFile(this.envSuccessPath, this.envSuccess);
+        }
+        if ((_b = this.envFailed) === null || _b === void 0 ? void 0 : _b.length) {
+            utils_1.fsUtil.writeFile(this.envFailsPath, this.envFailed);
+        }
+        (0, utils_1.log)(this.importConfig, 'Environments have been imported successfully!', 'success');
+    }
+    async importEnvironments() {
+        if (this.environments === undefined || (0, isEmpty_1.default)(this.environments)) {
+            (0, utils_1.log)(this.importConfig, 'No Environment Found', 'info');
+            return (0, node_path_1.resolve)();
+        }
+        const apiContent = (0, values_1.default)(this.environments);
+        const onSuccess = ({ response, apiData: { uid, name } = { uid: null, name: '' } }) => {
+            this.envSuccess.push(response);
+            this.envUidMapper[uid] = response.uid;
+            (0, utils_1.log)(this.importConfig, `Environment '${name}' imported successfully`, 'success');
+            utils_1.fsUtil.writeFile(this.envUidMapperPath, this.envUidMapper);
+        };
+        const onReject = ({ error, apiData }) => {
+            var _a;
+            const err = (error === null || error === void 0 ? void 0 : error.message) ? JSON.parse(error.message) : error;
+            const { name } = apiData;
+            if ((_a = err === null || err === void 0 ? void 0 : err.errors) === null || _a === void 0 ? void 0 : _a.name) {
+                (0, utils_1.log)(this.importConfig, `Environment '${name}' already exists`, 'info');
+            }
+            else {
+                this.envFailed.push(apiData);
+                (0, utils_1.log)(this.importConfig, `Environment '${name}' failed to be import. ${(0, utils_1.formatError)(error)}`, 'error');
+                (0, utils_1.log)(this.importConfig, error, 'error');
+            }
+        };
+        await this.makeConcurrentCall({
+            apiContent,
+            processName: 'import environments',
+            apiParams: {
+                serializeData: this.serializeEnvironments.bind(this),
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'create-environments',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: config_1.default.fetchConcurrency || 2,
+        }, undefined, false);
+    }
+    /**
+     * @method serializeEnvironments
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeEnvironments(apiOptions) {
+        const { apiData: environment } = apiOptions;
+        if (this.envUidMapper.hasOwnProperty(environment.uid)) {
+            (0, utils_1.log)(this.importConfig, `Environment '${environment.name}' already exists. Skipping it to avoid duplicates!`, 'info');
+            apiOptions.entity = undefined;
+        }
+        else {
+            apiOptions.apiData = environment;
+        }
+        return apiOptions;
+    }
+}
+exports.default = ImportEnvironments;

package/lib/import/modules/extensions.d.ts

@@ -0,0 +1,27 @@
+import BaseClass, { ApiOptions } from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class ImportExtensions extends BaseClass {
+    private mapperDirPath;
+    private extensionsFolderPath;
+    private extUidMapperPath;
+    private extSuccessPath;
+    private extFailsPath;
+    private extensionsConfig;
+    private extensions;
+    private extUidMapper;
+    private extSuccess;
+    private extFailed;
+    constructor({ importConfig, stackAPIClient }: ModuleClassParams);
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    start(): Promise<void>;
+    importExtensions(): Promise<any>;
+    /**
+     * @method serializeExtensions
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeExtensions(apiOptions: ApiOptions): ApiOptions;
+}

package/lib/import/modules/extensions.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const values_1 = tslib_1.__importDefault(require("lodash/values"));
+const node_path_1 = require("node:path");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class ImportExtensions extends base_class_1.default {
+    constructor({ importConfig, stackAPIClient }) {
+        super({ importConfig, stackAPIClient });
+        this.extensionsConfig = config_1.default.modules.extensions;
+        this.mapperDirPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'extensions');
+        this.extensionsFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, this.extensionsConfig.dirName);
+        this.extUidMapperPath = (0, node_path_1.join)(this.mapperDirPath, 'uid-mapping.json');
+        this.extSuccessPath = (0, node_path_1.join)(this.mapperDirPath, 'success.json');
+        this.extFailsPath = (0, node_path_1.join)(this.mapperDirPath, 'fails.json');
+        this.extFailed = [];
+        this.extSuccess = [];
+        this.extUidMapper = {};
+    }
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    async start() {
+        var _a, _b;
+        (0, utils_1.log)(this.importConfig, 'Migrating extensions', 'info');
+        //Step1 check folder exists or not
+        if (utils_1.fileHelper.fileExistsSync(this.extensionsFolderPath)) {
+            this.extensions = utils_1.fsUtil.readFile((0, node_path_1.join)(this.extensionsFolderPath, 'extensions.json'), true);
+        }
+        else {
+            (0, utils_1.log)(this.importConfig, `No such file or directory - '${this.extensionsFolderPath}'`, 'error');
+            return;
+        }
+        await utils_1.fsUtil.makeDirectory(this.mapperDirPath);
+        this.extUidMapper = utils_1.fileHelper.fileExistsSync(this.extUidMapperPath)
+            ? utils_1.fsUtil.readFile((0, node_path_1.join)(this.extUidMapperPath), true)
+            : {};
+        await this.importExtensions();
+        if ((_a = this.extSuccess) === null || _a === void 0 ? void 0 : _a.length) {
+            utils_1.fsUtil.writeFile(this.extSuccessPath, this.extSuccess);
+        }
+        if ((_b = this.extFailed) === null || _b === void 0 ? void 0 : _b.length) {
+            utils_1.fsUtil.writeFile(this.extFailsPath, this.extFailed);
+        }
+        (0, utils_1.log)(this.importConfig, 'Extensions have been imported successfully!', 'success');
+    }
+    async importExtensions() {
+        if (this.extensions === undefined || (0, isEmpty_1.default)(this.extensions)) {
+            (0, utils_1.log)(this.importConfig, 'No Extensions Found', 'info');
+            return (0, node_path_1.resolve)();
+        }
+        const apiContent = (0, values_1.default)(this.extensions);
+        const onSuccess = ({ response, apiData: { uid, title } = { uid: null, title: '' } }) => {
+            this.extSuccess.push(response);
+            this.extUidMapper[uid] = response.uid;
+            (0, utils_1.log)(this.importConfig, `Extension '${title}' imported successfully`, 'success');
+            utils_1.fsUtil.writeFile(this.extUidMapperPath, this.extUidMapper);
+        };
+        const onReject = ({ error, apiData }) => {
+            var _a;
+            const err = (error === null || error === void 0 ? void 0 : error.message) ? JSON.parse(error.message) : error;
+            const { title } = apiData;
+            if ((_a = err === null || err === void 0 ? void 0 : err.errors) === null || _a === void 0 ? void 0 : _a.title) {
+                (0, utils_1.log)(this.importConfig, `Extension '${title}' already exists`, 'info');
+            }
+            else {
+                this.extFailed.push(apiData);
+                (0, utils_1.log)(this.importConfig, `Extension '${title}' failed to be import ${(0, utils_1.formatError)(error)}`, 'error');
+                (0, utils_1.log)(this.importConfig, error, 'error');
+            }
+        };
+        await this.makeConcurrentCall({
+            apiContent,
+            processName: 'import extensions',
+            apiParams: {
+                serializeData: this.serializeExtensions.bind(this),
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'create-extensions',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: config_1.default.concurrency || config_1.default.fetchConcurrency || 1,
+        }, undefined, false);
+    }
+    /**
+     * @method serializeExtensions
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeExtensions(apiOptions) {
+        const { apiData: extension } = apiOptions;
+        if (this.extUidMapper.hasOwnProperty(extension.uid)) {
+            (0, utils_1.log)(this.importConfig, `Extension '${extension.title}' already exists. Skipping it to avoid duplicates!`, 'info');
+            apiOptions.entity = undefined;
+        }
+        else {
+            apiOptions.apiData = extension;
+        }
+        return apiOptions;
+    }
+}
+exports.default = ImportExtensions;

package/lib/import/modules/global-fields.d.ts

@@ -0,0 +1,34 @@
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+import { ModuleClassParams } from '../../types';
+import BaseClass, { ApiOptions } from './base-class';
+export default class ImportGlobalFields extends BaseClass {
+    private gFsMapperPath;
+    private gFsFolderPath;
+    private gFsFailsPath;
+    private gFsSuccessPath;
+    private gFsUidMapperPath;
+    private gFsPendingPath;
+    private pendingGFs;
+    private failedGFs;
+    private createdGFs;
+    private gFs;
+    private gFsUidMapper;
+    private config;
+    private stackAPIClient;
+    private marketplaceAppMapperPath;
+    private reqConcurrency;
+    private installedExtensions;
+    private gFsConfig;
+    constructor({ importConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<any>;
+    importGFs(): Promise<void>;
+    createGFs({ apiParams, element: globalField, isLastRequest, }: {
+        apiParams: ApiOptions;
+        element: Record<string, string>;
+        isLastRequest: boolean;
+    }): Promise<unknown>;
+}

package/lib/import/modules/global-fields.js

@@ -0,0 +1,99 @@
+"use strict";
+/* eslint-disable no-prototype-builtins */
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const lodash_1 = require("lodash");
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class ImportGlobalFields extends base_class_1.default {
+    constructor({ importConfig, stackAPIClient }) {
+        super({ importConfig, stackAPIClient });
+        this.config = importConfig;
+        this.gFsConfig = importConfig.modules['global-fields'];
+        this.gFs = [];
+        this.gFsUidMapper = {};
+        this.createdGFs = [];
+        this.failedGFs = [];
+        this.pendingGFs = [];
+        this.reqConcurrency = this.gFsConfig.writeConcurrency || this.config.writeConcurrency;
+        this.gFsMapperPath = path.resolve(this.config.data, 'mapper', 'global_fields');
+        this.gFsFolderPath = path.resolve(this.config.data, this.gFsConfig.dirName);
+        this.gFsFailsPath = path.resolve(this.config.data, 'mapper', 'global_fields', 'fails.json');
+        this.gFsSuccessPath = path.resolve(this.config.data, 'mapper', 'global_fields', 'success.json');
+        this.gFsUidMapperPath = path.resolve(this.config.data, 'mapper', 'global_fields', 'uid-mapping.json');
+        this.gFsPendingPath = path.resolve(this.config.data, 'mapper', 'global_fields', 'pending_global_fields.js');
+        this.marketplaceAppMapperPath = path.join(this.config.data, 'mapper', 'marketplace_apps', 'uid-mapping.json');
+    }
+    async start() {
+        this.gFs = utils_1.fsUtil.readFile(path.join(this.gFsFolderPath, this.gFsConfig.fileName));
+        if (!this.gFs || (0, lodash_1.isEmpty)(this.gFs)) {
+            (0, utils_1.log)(this.config, 'No global fields found to import', 'info');
+            return;
+        }
+        await utils_1.fsUtil.makeDirectory(this.gFsMapperPath);
+        if (utils_1.fileHelper.fileExistsSync(this.gFsUidMapperPath)) {
+            this.gFsUidMapper = (utils_1.fsUtil.readFile(this.gFsUidMapperPath) || {});
+        }
+        this.installedExtensions = ((await utils_1.fsUtil.readFile(this.marketplaceAppMapperPath)) || { extension_uid: {} }).extension_uid;
+        await this.importGFs();
+        utils_1.fsUtil.writeFile(this.gFsPendingPath, this.pendingGFs);
+        (0, utils_1.log)(this.config, 'Global fields import has been completed!', 'info');
+    }
+    async importGFs() {
+        const onSuccess = ({ response: globalField, apiData: { uid } = undefined }) => {
+            this.createdGFs.push(globalField);
+            this.gFsUidMapper[uid] = globalField;
+            utils_1.fsUtil.writeFile(this.gFsUidMapperPath, this.gFsUidMapper);
+            (0, utils_1.log)(this.config, 'Global field ' + uid + ' created successfully', 'success');
+        };
+        const onReject = ({ error, apiData: { uid } = undefined }) => {
+            (0, utils_1.log)(this.importConfig, `Global fields '${uid}' failed to import`, 'error');
+            (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            this.failedGFs.push({ uid });
+        };
+        return await this.makeConcurrentCall({
+            processName: 'Import global fields',
+            apiContent: this.gFs,
+            apiParams: {
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'create-gfs',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: this.reqConcurrency,
+        }, this.createGFs.bind(this));
+    }
+    async createGFs({ apiParams, element: globalField, isLastRequest, }) {
+        return new Promise(async (resolve, reject) => {
+            (0, utils_1.lookupExtension)(this.config, globalField.schema, this.config.preserveStackVersion, this.installedExtensions);
+            const isReferenceFieldRemoved = await (0, utils_1.removeReferenceFields)(globalField.schema, undefined, this.stackAPIClient);
+            if (isReferenceFieldRemoved) {
+                this.pendingGFs.push(globalField.uid);
+            }
+            return this.stack
+                .globalField()
+                .create({ global_field: globalField })
+                .then((response) => {
+                apiParams.resolve({
+                    response,
+                    apiData: globalField,
+                });
+                resolve(true);
+            })
+                .catch((error) => {
+                apiParams.reject({
+                    error,
+                    apiData: globalField,
+                });
+                reject(true);
+            });
+        });
+    }
+}
+exports.default = ImportGlobalFields;

package/lib/import/modules/index.d.ts

@@ -0,0 +1,2 @@
+import { ModuleClassParams } from '../../types';
+export default function startModuleImport(modulePayload: ModuleClassParams): Promise<any>;

package/lib/import/modules/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const node_path_1 = require("node:path");
+const modules_js_1 = tslib_1.__importDefault(require("../modules-js"));
+async function startModuleImport(modulePayload) {
+    var _a;
+    // Todo: Remove below code when auto detect mechanism implemented for old and new module
+    if (modulePayload.moduleName === 'assets' &&
+        !new cli_utilities_1.FsUtility({ basePath: (0, node_path_1.join)((_a = modulePayload.importConfig) === null || _a === void 0 ? void 0 : _a.backupDir, 'assets') }).isNewFsStructure) {
+        return (0, modules_js_1.default)(modulePayload);
+    }
+    const { default: ModuleRunner } = await (_a = `./${modulePayload.moduleName}`, Promise.resolve().then(() => tslib_1.__importStar(require(_a))));
+    const moduleRunner = new ModuleRunner(modulePayload);
+    return moduleRunner.start();
+}
+exports.default = startModuleImport;

package/lib/import/modules/labels.d.ts

@@ -0,0 +1,34 @@
+import BaseClass, { ApiOptions } from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class Importlabels extends BaseClass {
+    private mapperDirPath;
+    private labelsFolderPath;
+    private labelUidMapperPath;
+    private createdLabelPath;
+    private labelFailsPath;
+    private labelsConfig;
+    private labels;
+    private labelUidMapper;
+    private createdLabel;
+    private failedLabel;
+    constructor({ importConfig, stackAPIClient }: ModuleClassParams);
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    start(): Promise<void>;
+    importlabels(): Promise<string>;
+    /**
+     * @method serializelabels
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializelabels(apiOptions: ApiOptions): ApiOptions;
+    updateLabels(): Promise<void>;
+    /**
+     * @method serializeUpdatelabels
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeUpdatelabels(apiOptions: ApiOptions): ApiOptions;
+}

package/lib/import/modules/labels.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const values_1 = tslib_1.__importDefault(require("lodash/values"));
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const node_path_1 = require("node:path");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class Importlabels extends base_class_1.default {
+    constructor({ importConfig, stackAPIClient }) {
+        super({ importConfig, stackAPIClient });
+        this.labelsConfig = config_1.default.modules.labels;
+        this.mapperDirPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'labels');
+        this.labelsFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, this.labelsConfig.dirName);
+        this.labelUidMapperPath = (0, node_path_1.join)(this.mapperDirPath, 'uid-mapping.json');
+        this.createdLabelPath = (0, node_path_1.join)(this.mapperDirPath, 'success.json');
+        this.labelFailsPath = (0, node_path_1.join)(this.mapperDirPath, 'fails.json');
+        this.labels = {};
+        this.failedLabel = [];
+        this.createdLabel = [];
+        this.labelUidMapper = {};
+    }
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    async start() {
+        var _a, _b;
+        (0, utils_1.log)(this.importConfig, 'Migrating labels', 'info');
+        //Step1 check folder exists or not
+        if (utils_1.fileHelper.fileExistsSync(this.labelsFolderPath)) {
+            this.labels = utils_1.fsUtil.readFile((0, node_path_1.join)(this.labelsFolderPath, 'labels.json'), true);
+        }
+        else {
+            (0, utils_1.log)(this.importConfig, `No such file or directory - '${this.labelsFolderPath}'`, 'error');
+            return;
+        }
+        //create labels in mapper directory
+        await utils_1.fsUtil.makeDirectory(this.mapperDirPath);
+        this.labelUidMapper = utils_1.fileHelper.fileExistsSync(this.labelUidMapperPath)
+            ? utils_1.fsUtil.readFile((0, node_path_1.join)(this.labelUidMapperPath), true)
+            : {};
+        await this.importlabels();
+        //update parent in created label
+        await this.updateLabels();
+        if ((_a = this.createdLabel) === null || _a === void 0 ? void 0 : _a.length) {
+            utils_1.fsUtil.writeFile(this.createdLabelPath, this.createdLabel);
+        }
+        if ((_b = this.failedLabel) === null || _b === void 0 ? void 0 : _b.length) {
+            utils_1.fsUtil.writeFile(this.labelFailsPath, this.failedLabel);
+        }
+        (0, utils_1.log)(this.importConfig, 'Labels have been imported successfully!', 'success');
+    }
+    async importlabels() {
+        if (this.labels === undefined || (0, isEmpty_1.default)(this.labels)) {
+            (0, utils_1.log)(this.importConfig, 'No Label Found', 'info');
+            return (0, node_path_1.resolve)();
+        }
+        const apiContent = (0, values_1.default)(this.labels);
+        const onSuccess = ({ response, apiData: { uid, name } = { uid: null, name: '' } }) => {
+            this.labelUidMapper[uid] = response;
+            (0, utils_1.log)(this.importConfig, `Label '${name}' imported successfully`, 'success');
+            utils_1.fsUtil.writeFile(this.labelUidMapperPath, this.labelUidMapper);
+        };
+        const onReject = ({ error, apiData }) => {
+            var _a;
+            const err = (error === null || error === void 0 ? void 0 : error.message) ? JSON.parse(error.message) : error;
+            const { name } = apiData;
+            if ((_a = err === null || err === void 0 ? void 0 : err.errors) === null || _a === void 0 ? void 0 : _a.name) {
+                (0, utils_1.log)(this.importConfig, `Label '${name}' already exists`, 'info');
+            }
+            else {
+                this.failedLabel.push(apiData);
+                (0, utils_1.log)(this.importConfig, `Label '${name}' failed to be import. ${(0, utils_1.formatError)(error)}`, 'error');
+            }
+        };
+        await this.makeConcurrentCall({
+            apiContent,
+            processName: 'create labels',
+            apiParams: {
+                serializeData: this.serializelabels.bind(this),
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'create-labels',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: config_1.default.fetchConcurrency || 1,
+        }, undefined, false);
+    }
+    /**
+     * @method serializelabels
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializelabels(apiOptions) {
+        var _a;
+        const { apiData: label } = apiOptions;
+        if (this.labelUidMapper.hasOwnProperty(label.uid)) {
+            (0, utils_1.log)(this.importConfig, `Label '${label.name}' already exists. Skipping it to avoid duplicates!`, 'info');
+            apiOptions.entity = undefined;
+        }
+        else {
+            let labelReq = label;
+            if (((_a = label === null || label === void 0 ? void 0 : label.parent) === null || _a === void 0 ? void 0 : _a.length) != 0) {
+                labelReq = (0, omit_1.default)(label, ['parent']);
+            }
+            apiOptions.apiData = labelReq;
+        }
+        return apiOptions;
+    }
+    async updateLabels() {
+        if (!(0, isEmpty_1.default)(this.labels)) {
+            const apiContent = (0, values_1.default)(this.labels);
+            const onSuccess = ({ response, apiData: { uid, name } = { uid: null, name: '' } }) => {
+                this.createdLabel.push(response);
+                (0, utils_1.log)(this.importConfig, `Label '${name}' updated successfully`, 'success');
+            };
+            const onReject = ({ error, apiData }) => {
+                (0, utils_1.log)(this.importConfig, `Failed to update label '${apiData === null || apiData === void 0 ? void 0 : apiData.name}'. ${(0, utils_1.formatError)(error)}`, 'error');
+            };
+            await this.makeConcurrentCall({
+                apiContent,
+                processName: 'update labels',
+                apiParams: {
+                    serializeData: this.serializeUpdatelabels.bind(this),
+                    reject: onReject.bind(this),
+                    resolve: onSuccess.bind(this),
+                    entity: 'update-labels',
+                    includeParamOnCompletion: true,
+                },
+                concurrencyLimit: config_1.default.fetchConcurrency || 1,
+            }, undefined, false);
+        }
+    }
+    /**
+     * @method serializeUpdatelabels
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeUpdatelabels(apiOptions) {
+        var _a, _b;
+        const { apiData: label } = apiOptions;
+        const labelUid = label.uid;
+        if (this.labelUidMapper.hasOwnProperty(labelUid)) {
+            const newLabel = this.labelUidMapper[labelUid];
+            if (((_a = label === null || label === void 0 ? void 0 : label.parent) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                for (let i = 0; i < ((_b = label === null || label === void 0 ? void 0 : label.parent) === null || _b === void 0 ? void 0 : _b.length); i++) {
+                    const parentUid = label.parent[i];
+                    if (this.labelUidMapper.hasOwnProperty(parentUid)) {
+                        const mappedLabel = this.labelUidMapper[parentUid];
+                        label.parent[i] = mappedLabel.uid;
+                    }
+                }
+                const createdLabelRes = this.labelUidMapper[labelUid];
+                createdLabelRes.parent = label.parent;
+                apiOptions.apiData = createdLabelRes;
+            }
+            else {
+                apiOptions.entity = undefined;
+                this.createdLabel.push(newLabel);
+            }
+        }
+        else {
+            apiOptions.entity = undefined;
+        }
+        return apiOptions;
+    }
+}
+exports.default = Importlabels;

package/lib/import/modules/locales.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+import { ModuleClassParams } from '../../types';
+import BaseClass from './base-class';
+export default class ImportLocales extends BaseClass {
+    private langMapperPath;
+    private langFolderPath;
+    private langFailsPath;
+    private langSuccessPath;
+    private langUidMapperPath;
+    private languages;
+    private config;
+    private stackAPIClient;
+    private failedLocales;
+    private createdLocales;
+    private langUidMapper;
+    private localeConfig;
+    client: any;
+    private reqConcurrency;
+    private masterLanguage;
+    private masterLanguageConfig;
+    private sourceMasterLanguage;
+    constructor({ importConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<any>;
+    checkAndUpdateMasterLocale(): Promise<any>;
+    createLocales(): Promise<any>;
+    updateLocales(): Promise<unknown>;
+}