@contentstack/cli-cm-import 1.28.1 → 2.0.1-beta

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

@@ -1,13 +0,0 @@
-export = ImportEnvironments;
-declare class ImportEnvironments {
-    constructor(importConfig: any, stackAPIClient: any);
-    fails: any[];
-    success: any[];
-    envUidMapper: {};
-    fetchConcurrency: any;
-    config: any;
-    stackAPIClient: any;
-    start(): Promise<any>;
-    environments: any;
-}
-import Promise = require("bluebird");

package/lib/import/modules-js/environments.js

@@ -1,85 +0,0 @@
-/*!
- * Contentstack Import
- * Copyright (c) 2024 Contentstack LLC
- * MIT Licensed
- */
-const fs = require('fs');
-const path = require('path');
-const chalk = require('chalk');
-const mkdirp = require('mkdirp');
-const Promise = require('bluebird');
-const { isEmpty, merge } = require('lodash');
-const { readFileSync, writeFileSync } = require('../../utils/file-helper');
-const { log } = require('../../utils/logger');
-const { formatError } = require('../../utils');
-const config = require('../../config').default;
-module.exports = class ImportEnvironments {
-    constructor(importConfig, stackAPIClient) {
-        this.fails = [];
-        this.success = [];
-        this.envUidMapper = {};
-        this.fetchConcurrency = config.modules.environments.concurrency || config.fetchConcurrency || 2;
-        this.config = importConfig;
-        this.stackAPIClient = stackAPIClient;
-    }
-    start() {
-        log(this.config, 'Migrating environment', 'success');
-        const self = this;
-        let environmentConfig = config.modules.environments;
-        let environmentsFolderPath = path.resolve(this.config.data, environmentConfig.dirName);
-        let envMapperPath = path.resolve(this.config.data, 'mapper', 'environments');
-        let envUidMapperPath = path.resolve(this.config.data, 'mapper', 'environments', 'uid-mapping.json');
-        let envSuccessPath = path.resolve(this.config.data, 'environments', 'success.json');
-        let envFailsPath = path.resolve(this.config.data, 'environments', 'fails.json');
-        self.environments = readFileSync(path.resolve(environmentsFolderPath, environmentConfig.fileName));
-        if (fs.existsSync(envUidMapperPath)) {
-            self.envUidMapper = readFileSync(envUidMapperPath);
-            self.envUidMapper = self.envUidMapper || {};
-        }
-        mkdirp.sync(envMapperPath);
-        return new Promise(function (resolve, reject) {
-            if (self.environments === undefined || isEmpty(self.environments)) {
-                log(self.config, chalk.yellow('No Environment Found'), 'success');
-                return resolve({ empty: true });
-            }
-            let envUids = Object.keys(self.environments);
-            return Promise.map(envUids, function (envUid) {
-                let env = self.environments[envUid];
-                if (!self.envUidMapper.hasOwnProperty(envUid)) {
-                    let requestOption = { environment: env };
-                    return self.stackAPIClient
-                        .environment()
-                        .create(requestOption)
-                        .then((environment) => {
-                        self.success.push(environment.items);
-                        self.envUidMapper[envUid] = environment.uid;
-                        writeFileSync(envUidMapperPath, self.envUidMapper);
-                    })
-                        .catch(function (err) {
-                        let error = JSON.parse(err.message);
-                        if (error.errors.name) {
-                            log(self.config, `Environment '${env.name}' already exists`, 'error');
-                        }
-                        else {
-                            log(config, `Environment '${env.name}' failed to be import\n ${JSON.stringify(error.errors)}`, 'error');
-                        }
-                    });
-                }
-                else {
-                    // the environment has already been created
-                    log(config, `The environment '${env.name}' already exists. Skipping it to avoid duplicates!`, 'success');
-                }
-            }, { concurrency: self.fetchConcurrency })
-                .then(function () {
-                writeFileSync(envSuccessPath, self.success);
-                log(self.config, chalk.green('Environments have been imported successfully!'), 'success');
-                resolve('');
-            })
-                .catch(function (error) {
-                writeFileSync(envFailsPath, self.fails);
-                log(self.config, `Failed to import environment ${formatError(error)}`, 'error');
-                reject(error);
-            });
-        });
-    }
-};

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

@@ -1,18 +0,0 @@
-export = ImportExtensions;
-declare class ImportExtensions {
-    constructor(importConfig: any, stackAPIClient: any);
-    fails: any[];
-    success: any[];
-    extUidMapper: {};
-    extensionsConfig: {
-        dirName: string;
-        fileName: string;
-        validKeys: string[];
-    };
-    reqConcurrency: number;
-    config: any;
-    stackAPIClient: any;
-    start(): Promise<any>;
-    extensions: any;
-}
-import Promise = require("bluebird");

package/lib/import/modules-js/extensions.js

@@ -1,86 +0,0 @@
-/*!
- * Contentstack Import
- * Copyright (c) 2024 Contentstack LLC
- * MIT Licensed
- */
-const mkdirp = require('mkdirp');
-const fs = require('fs');
-const path = require('path');
-const Promise = require('bluebird');
-const chalk = require('chalk');
-const { isEmpty, merge } = require('lodash');
-const { default: config } = require('../../config');
-const { fileHelper, log, formatError } = require('../../utils');
-module.exports = class ImportExtensions {
-    constructor(importConfig, stackAPIClient) {
-        this.fails = [];
-        this.success = [];
-        this.extUidMapper = {};
-        this.extensionsConfig = config.modules.extensions;
-        this.reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
-        this.config = merge(config, importConfig);
-        this.stackAPIClient = stackAPIClient;
-    }
-    start() {
-        log(this.config, chalk.white('Migrating extensions'), 'success');
-        const self = this;
-        let extensionsFolderPath = path.resolve(this.config.data, this.extensionsConfig.dirName);
-        let extMapperPath = path.resolve(this.config.data, 'mapper', 'extensions');
-        let extUidMapperPath = path.resolve(this.config.data, 'mapper/extensions', 'uid-mapping.json');
-        let extSuccessPath = path.resolve(this.config.data, 'extensions', 'success.json');
-        let extFailsPath = path.resolve(this.config.data, 'extensions', 'fails.json');
-        this.extensions = fileHelper.readFileSync(path.resolve(extensionsFolderPath, this.extensionsConfig.fileName));
-        if (fs.existsSync(extUidMapperPath)) {
-            self.extUidMapper = fileHelper.readFileSync(extUidMapperPath);
-            self.extUidMapper = self.extUidMapper || {};
-        }
-        mkdirp.sync(extMapperPath);
-        return new Promise(function (resolve, reject) {
-            if (self.extensions === undefined || isEmpty(self.extensions)) {
-                log(self.config, chalk.white('No Extensions Found'), 'success');
-                return resolve({ empty: true });
-            }
-            let extUids = Object.keys(self.extensions);
-            return Promise.map(extUids, function (extUid) {
-                let ext = self.extensions[extUid];
-                if (!self.extUidMapper.hasOwnProperty(extUid)) {
-                    return self.stackAPIClient
-                        .extension()
-                        .create({ extension: ext })
-                        .then((response) => {
-                        self.success.push(response);
-                        self.extUidMapper[extUid] = response.uid;
-                        fileHelper.writeFileSync(extUidMapperPath, self.extUidMapper);
-                    })
-                        .catch(function (err) {
-                        let error = JSON.parse(err.message);
-                        self.fails.push(ext);
-                        if (error.errors.title) {
-                            log(self.config, `Extension '${ext.title}' already exists`, 'error');
-                        }
-                        else {
-                            log(self.config, "Extension: '" + ext.title + "' failed to import" + formatError(error), 'error');
-                        }
-                    });
-                }
-                // the extensions has already been created
-                log(config, chalk.white("The extension: '" + ext.title + "' already exists. Skipping it to avoid duplicates!"), 'success');
-                // import 2 extensions at a time
-            }, {
-                concurrency: self.reqConcurrency,
-            })
-                .then(function () {
-                // extensions have imported successfully
-                fileHelper.writeFileSync(extSuccessPath, self.success);
-                log(self.config, chalk.green('Extensions have been imported successfully!'), 'success');
-                resolve();
-            })
-                .catch(function (error) {
-                // error while importing extensions
-                fileHelper.writeFileSync(extFailsPath, self.fails);
-                log(self.config, `Extension import failed ${formatError(error)}`, 'error');
-                reject(error);
-            });
-        });
-    }
-};

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

@@ -1,13 +0,0 @@
-export = ImportGlobalFields;
-declare class ImportGlobalFields {
-    constructor(importConfig: any, stackAPIClient: any);
-    fails: any[];
-    success: any[];
-    snipUidMapper: {};
-    installedExtensions: any[];
-    reqConcurrency: number;
-    config: any;
-    stackAPIClient: any;
-    start(): globalThis.Promise<any>;
-    globalfields: any;
-}

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

@@ -1,106 +0,0 @@
-/*!
- * Contentstack Import
- * Copyright (c) 2024 Contentstack LLC
- * MIT Licensed
- */
-let fs = require('fs');
-let path = require('path');
-let chalk = require('chalk');
-let mkdirp = require('mkdirp');
-let Promise = require('bluebird');
-const { isEmpty, merge } = require('lodash');
-let { default: config } = require('../../config');
-const { fileHelper, log, formatError, lookupExtension, removeReferenceFields } = require('../../utils');
-global._globalField_pending = [];
-module.exports = class ImportGlobalFields {
-    constructor(importConfig, stackAPIClient) {
-        this.fails = [];
-        this.success = [];
-        this.snipUidMapper = {};
-        this.installedExtensions = [];
-        this.reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
-        this.config = merge(config, importConfig);
-        this.stackAPIClient = stackAPIClient;
-    }
-    async start() {
-        log(this.config, chalk.white('Migrating global-fields'), 'success');
-        let self = this;
-        let globalfieldsConfig = config.modules.globalfields;
-        let globalfieldsFolderPath = path.resolve(this.config.data, globalfieldsConfig.dirName);
-        let globalfieldsMapperPath = path.resolve(this.config.data, 'mapper', 'global_fields');
-        let globalfieldsUidMapperPath = path.resolve(this.config.data, 'mapper', 'global_fields', 'uid-mapping.json');
-        let globalfieldsSuccessPath = path.resolve(this.config.data, 'mapper', 'global_fields', 'success.json');
-        let globalFieldsPending = path.resolve(this.config.data, 'mapper', 'global_fields', 'pending_global_fields.js');
-        let globalfieldsFailsPath = path.resolve(this.config.data, 'mapper', 'global_fields', 'fails.json');
-        self.globalfields = fileHelper.readFileSync(path.resolve(globalfieldsFolderPath, globalfieldsConfig.fileName));
-        const appMapperPath = path.join(this.config.data, 'mapper', 'marketplace_apps', 'uid-mapping.json');
-        this.installedExtensions = ((await fileHelper.readFileSync(appMapperPath)) || { extension_uid: {} }).extension_uid;
-        if (fs.existsSync(globalfieldsUidMapperPath)) {
-            self.snipUidMapper = fileHelper.readFileSync(globalfieldsUidMapperPath);
-            self.snipUidMapper = self.snipUidMapper || {};
-        }
-        if (!fs.existsSync(globalfieldsMapperPath)) {
-            mkdirp.sync(globalfieldsMapperPath);
-        }
-        return new Promise(function (resolve, reject) {
-            if (self.globalfields === undefined || isEmpty(self.globalfields)) {
-                log(self.config, chalk.white('No globalfields Found'), 'success');
-                fileHelper.writeFileSync(globalFieldsPending, _globalField_pending);
-                return resolve({ empty: true });
-            }
-            let snipUids = Object.keys(self.globalfields);
-            return Promise.map(snipUids, async function (snipUid) {
-                let flag = { supressed: false };
-                let snip = self.globalfields[snipUid];
-                lookupExtension(self.config, snip.schema, self.config.preserveStackVersion, self.installedExtensions);
-                await removeReferenceFields(snip.schema, flag, self.stackAPIClient);
-                if (flag.supressed) {
-                    // eslint-disable-next-line no-undef
-                    _globalField_pending.push(snip.uid);
-                }
-                if (!self.snipUidMapper.hasOwnProperty(snipUid)) {
-                    let requestOption = { global_field: snip };
-                    return self.stackAPIClient
-                        .globalField()
-                        .create(requestOption)
-                        .then((globalField) => {
-                        self.success.push(globalField.items);
-                        let global_field_uid = globalField.uid;
-                        self.snipUidMapper[snipUid] = globalField.items;
-                        fileHelper.writeFileSync(globalfieldsUidMapperPath, self.snipUidMapper);
-                        log(self.config, chalk.green('Global field ' + global_field_uid + ' created successfully'), 'success');
-                    })
-                        .catch(function (err) {
-                        let error = JSON.parse(err.message);
-                        if (error.errors.title) {
-                            // eslint-disable-next-line no-undef
-                            log(self.config, `Globalfield '${snip.uid} already exists'`, 'error');
-                        }
-                        else {
-                            log(self.config, chalk.red(`Globalfield '${snip.title}' failed to import. ${formatError(error)}`), 'error');
-                        }
-                        self.fails.push(snip);
-                    });
-                }
-                else {
-                    // globalfields has already been created
-                    log(self.config, chalk.white('The globalfields already exists. Skipping it to avoid duplicates!'), 'success');
-                }
-                // import 2 globalfields at a time
-            }, { concurrency: self.reqConcurrency })
-                .then(function () {
-                // globalfields have imported successfully
-                fileHelper.writeFileSync(globalfieldsSuccessPath, self.success);
-                fileHelper.writeFileSync(globalFieldsPending, _globalField_pending);
-                log(self.config, chalk.green('globalfields have been imported successfully!'), 'success');
-                return resolve();
-            })
-                .catch(function (err) {
-                let error = JSON.parse(err);
-                fileHelper.writeFileSync(globalfieldsFailsPath, self.fails);
-                log(self.config, `Globalfields import failed. ${formatError(err)}`, 'error');
-                return reject(error);
-            });
-        });
-    }
-};

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

@@ -1 +0,0 @@
-export default function startModuleImport(modulePayload: any): Promise<any>;

package/lib/import/modules-js/index.js

@@ -1,33 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-async function startModuleImport(modulePayload) {
-    const { moduleName, importConfig, stackAPIClient } = modulePayload;
-    const { default: ModuleRunner } = await (_a = `./${moduleName}`, Promise.resolve().then(() => __importStar(require(_a))));
-    const moduleRunner = new ModuleRunner(importConfig, stackAPIClient);
-    return moduleRunner.start();
-}
-exports.default = startModuleImport;

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

@@ -1,20 +0,0 @@
-export = ImportLabels;
-declare class ImportLabels {
-    constructor(importConfig: any, stackAPIClient: any);
-    config: any;
-    fails: any[];
-    success: any[];
-    labelUids: any[];
-    labelsFolderPath: any;
-    labelUidMapper: {};
-    labelConfig: {
-        dirName: string;
-        fileName: string;
-    };
-    reqConcurrency: number;
-    stackAPIClient: any;
-    start(): Promise<any>;
-    labels: any;
-    updateLabels(): Promise<any>;
-}
-import Promise = require("bluebird");

package/lib/import/modules-js/labels.js

@@ -1,148 +0,0 @@
-/*!
- * Contentstack Import
- * Copyright (c) 2024 Contentstack LLC
- * MIT Licensed
- */
-const path = require('path');
-const chalk = require('chalk');
-const mkdirp = require('mkdirp');
-const Promise = require('bluebird');
-const { existsSync } = require('fs');
-const { isEmpty, merge } = require('lodash');
-let { default: config } = require('../../config');
-const { fileHelper, log, formatError } = require('../../utils');
-module.exports = class ImportLabels {
-    constructor(importConfig, stackAPIClient) {
-        this.fails = [];
-        this.success = [];
-        this.labelUids = [];
-        this.labelUidMapper = {};
-        this.labelConfig = config.modules.labels;
-        this.reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
-        this.config = merge(config, importConfig);
-        this.stackAPIClient = stackAPIClient;
-    }
-    start() {
-        const self = this;
-        log(this.config, chalk.white('Migrating labels'), 'success');
-        let labelMapperPath = path.resolve(this.config.data, 'mapper', 'labels');
-        let labelFailsPath = path.resolve(this.config.data, 'labels', 'fails.json');
-        let labelSuccessPath = path.resolve(this.config.data, 'labels', 'success.json');
-        this.labelsFolderPath = path.resolve(this.config.data, this.labelConfig.dirName);
-        let labelUidMapperPath = path.resolve(this.config.data, 'mapper', 'labels', 'uid-mapping.json');
-        if (existsSync(labelUidMapperPath)) {
-            this.labelUidMapper = fileHelper.readFileSync(labelUidMapperPath);
-            this.labelUidMapper = this.labelUidMapper || {};
-        }
-        self.labels = fileHelper.readFileSync(path.resolve(this.labelsFolderPath, this.labelConfig.fileName));
-        mkdirp.sync(labelMapperPath);
-        return new Promise(function (resolve, reject) {
-            if (self.labels == undefined || isEmpty(self.labels)) {
-                log(self.config, chalk.white('No Label Found'), 'success');
-                return resolve({ empty: true });
-            }
-            self.labelUids = Object.keys(self.labels);
-            return Promise.map(self.labelUids, function (labelUid) {
-                let label = self.labels[labelUid];
-                if (label.parent.length != 0) {
-                    delete label['parent'];
-                }
-                if (!self.labelUidMapper.hasOwnProperty(labelUid)) {
-                    let requestOption = { label: label };
-                    return self.stackAPIClient
-                        .label()
-                        .create(requestOption)
-                        .then(function (response) {
-                        self.labelUidMapper[labelUid] = response;
-                    })
-                        .catch(function (error) {
-                        self.fails.push(label);
-                        if (error.errors.name) {
-                            log(self.config, `Label '${label.name}' already exist`, 'error');
-                        }
-                        else {
-                            log(self.config, `Label '${label.name}' failed to be imported\n`, 'error');
-                        }
-                    });
-                }
-                else {
-                    // the label has already been created
-                    log(self.config, chalk.white(`The label '${label.name}' already exists. Skipping it to avoid duplicates!'`), 'success');
-                }
-                // import 1 labels at a time
-            }, { concurrency: self.reqConcurrency })
-                .then(function () {
-                fileHelper.writeFileSync(labelUidMapperPath, self.labelUidMapper);
-                // eslint-disable-next-line no-undef
-                return self
-                    .updateLabels()
-                    .then(function () {
-                    fileHelper.writeFileSync(labelSuccessPath, self.success);
-                    log(self.config, chalk.green('Labels have been imported successfully!'), 'success');
-                    return resolve();
-                })
-                    .catch(function (error) {
-                    log(self.config, self.config, `Failed to import label, ${formatError(error)}`, 'error');
-                    // eslint-disable-next-line no-console
-                    return reject(error);
-                });
-            })
-                .catch(function (error) {
-                // error while importing labels
-                fileHelper.writeFileSync(labelUidMapperPath, self.labelUidMapper);
-                fileHelper.writeFileSync(labelFailsPath, self.fails);
-                log(self.config, `Failed to import label, ${formatError(error)}`, 'error');
-                return reject(error);
-            });
-        });
-    }
-    updateLabels() {
-        const self = this;
-        return new Promise(function (resolve, reject) {
-            let labelsObj = fileHelper.readFileSync(path.resolve(self.labelsFolderPath, self.labelConfig.fileName));
-            return Promise.map(self.labelUids, function (labelUid) {
-                let label = labelsObj[labelUid];
-                if (self.labelUidMapper.hasOwnProperty(labelUid)) {
-                    let newLabelUid = self.labelUidMapper[labelUid];
-                    if (label.parent.length > 0) {
-                        let parentUids = label.parent;
-                        for (let i = 0; i < parentUids.length; i++) {
-                            if (self.labelUidMapper.hasOwnProperty(parentUids[i])) {
-                                label.parent[i] = self.labelUidMapper[parentUids[i]].uid;
-                            }
-                        }
-                        return self.stackAPIClient
-                            .label(newLabelUid.uid)
-                            .fetch()
-                            .then(function (response) {
-                            //Object.assign(response, _.cloneDeep(label))
-                            response.parent = label.parent;
-                            response
-                                .update()
-                                .then((result) => {
-                                self.success.push(result);
-                            })
-                                .catch((error) => {
-                                log(self.config, formatError(error), 'error');
-                                return reject(error);
-                            });
-                        })
-                            .catch(function (error) {
-                            log(self.config, formatError(error), 'error');
-                            return reject(error);
-                        });
-                    }
-                }
-            }, {
-                concurrency: self.reqConcurrency,
-            })
-                .then(function () {
-                return resolve();
-            })
-                .catch(function (error) {
-                // eslint-disable-next-line no-console
-                return reject(error);
-            });
-        });
-    }
-};

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

@@ -1,24 +0,0 @@
-export = ImportLanguages;
-declare class ImportLanguages {
-    constructor(importConfig: any, stackAPIClient: any);
-    config: any;
-    stackAPIClient: any;
-    fails: any[];
-    success: any[];
-    langUidMapper: {};
-    masterLanguage: any;
-    langConfig: any;
-    sourceMasterLangConfig: {
-        dirName: string;
-        fileName: string;
-        requiredKeys: string[];
-    };
-    reqConcurrency: any;
-    start(): Promise<any>;
-    langSuccessPath: string;
-    languages: any;
-    sourceMasterLanguages: any;
-    updateLocales(langUids: any): Promise<any>;
-    checkAndUpdateMasterLocaleName(sourceMasterLangDetails: any): Promise<any>;
-}
-import Promise = require("bluebird");