@contentstack/cli-cm-import 1.5.11 → 1.7.0

package/lib/utils/common-helper.js

@@ -0,0 +1,244 @@
+"use strict";
+/* eslint-disable no-console */
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBranch = exports.executeTask = exports.formatError = exports.getConfig = exports.field_rules_update = exports.masterLocalDetails = exports.sanitizeStack = exports.buildAppConfig = exports.validateConfig = exports.initialization = void 0;
+const tslib_1 = require("tslib");
+const _ = tslib_1.__importStar(require("lodash"));
+const path = tslib_1.__importStar(require("path"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const file_helper_1 = require("./file-helper");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const logger_1 = require("./logger");
+const config_1 = tslib_1.__importDefault(require("../config"));
+const promise_limit_1 = tslib_1.__importDefault(require("promise-limit"));
+let config;
+const initialization = (configData) => {
+    config = (0, exports.buildAppConfig)(configData);
+    const res = (0, exports.validateConfig)(config);
+    if ((res && res !== 'error') || res === undefined) {
+        return config;
+    }
+};
+exports.initialization = initialization;
+const validateConfig = (importConfig) => {
+    if (importConfig.email && importConfig.password && !importConfig.target_stack) {
+        (0, logger_1.log)(importConfig, chalk_1.default.red('Kindly provide api_token'), 'error');
+        return 'error';
+    }
+    else if (!importConfig.email &&
+        !importConfig.password &&
+        !importConfig.management_token &&
+        importConfig.target_stack &&
+        !(0, cli_utilities_1.isAuthenticated)()) {
+        (0, logger_1.log)(importConfig, chalk_1.default.red('Kindly provide management_token or email and password'), 'error');
+        return 'error';
+    }
+    else if (!importConfig.email && !importConfig.password && importConfig.preserveStackVersion) {
+        (0, logger_1.log)(importConfig, chalk_1.default.red('Kindly provide Email and password for old version stack'), 'error');
+        return 'error';
+    }
+    else if ((importConfig.email && !importConfig.password) || (!importConfig.email && importConfig.password)) {
+        (0, logger_1.log)(importConfig, chalk_1.default.red('Kindly provide Email and password'), 'error');
+        return 'error';
+    }
+};
+exports.validateConfig = validateConfig;
+const buildAppConfig = (importConfig) => {
+    importConfig = _.merge(config_1.default, importConfig);
+    return importConfig;
+};
+exports.buildAppConfig = buildAppConfig;
+const sanitizeStack = (importConfig) => {
+    if (typeof importConfig.preserveStackVersion !== 'boolean' || !importConfig.preserveStackVersion) {
+        return Promise.resolve();
+    }
+    (0, logger_1.log)(importConfig, 'Running script to maintain stack version.', 'success');
+    try {
+        const httpClient = cli_utilities_1.HttpClient.create();
+        httpClient.headers(importConfig.headers);
+        return httpClient.get(`https://${importConfig.host}/v3${importConfig.apis.stacks}`).then((stackDetails) => {
+            if (stackDetails.data && stackDetails.data.stack && stackDetails.data.stack.settings) {
+                const newStackVersion = stackDetails.data.stack.settings.version;
+                const newStackDate = new Date(newStackVersion).toString();
+                const stackFilePath = path.join(importConfig.data, importConfig.modules.stack.dirName, importConfig.modules.stack.fileName);
+                const oldStackDetails = (0, file_helper_1.readFileSync)(stackFilePath);
+                if (!oldStackDetails || !oldStackDetails.settings || !oldStackDetails.settings.hasOwnProperty('version')) {
+                    throw new Error(`${JSON.stringify(oldStackDetails)} is invalid!`);
+                }
+                const oldStackDate = new Date(oldStackDetails.settings.version).toString();
+                if (oldStackDate > newStackDate) {
+                    throw new Error('Migration Error. You cannot migrate data from new stack onto old. Kindly contact support@contentstack.com for more details.');
+                }
+                else if (oldStackDate === newStackDate) {
+                    (0, logger_1.log)(importConfig, 'The version of both the stacks are same.', 'success');
+                    return Promise.resolve();
+                }
+                (0, logger_1.log)(importConfig, 'Updating stack version.', 'success');
+                return httpClient
+                    .put(`https://${importConfig.host}/v3${importConfig.apis.stacks}settings/set-version`, {
+                    stack_settings: {
+                        version: '2017-10-14', // This can be used as a variable
+                    },
+                })
+                    .then((response) => {
+                    (0, logger_1.log)(importConfig, `Stack version preserved successfully!\n${JSON.stringify(response.data)}`, 'success');
+                });
+            }
+            throw new Error(`Unexpected stack details ${stackDetails && JSON.stringify(stackDetails.data)}`);
+        });
+    }
+    catch (error) {
+        console.log(error);
+    }
+};
+exports.sanitizeStack = sanitizeStack;
+const masterLocalDetails = (stackAPIClient) => {
+    return new Promise((resolve, reject) => {
+        const result = stackAPIClient.locale().query();
+        result
+            .find()
+            .then((response) => {
+            const masterLocalObj = response.items.filter((obj) => {
+                if (obj.fallback_locale === null) {
+                    return obj;
+                }
+            });
+            return resolve(masterLocalObj[0]);
+        })
+            .catch((error) => {
+            return reject(error);
+        });
+    });
+};
+exports.masterLocalDetails = masterLocalDetails;
+const field_rules_update = (importConfig, ctPath) => {
+    return new Promise(async (resolve, reject) => {
+        let client = await (0, cli_utilities_1.managementSDKClient)(config);
+        (0, file_helper_1.readFile)(path.join(ctPath + '/field_rules_uid.json'))
+            .then(async (data) => {
+            const ct_field_visibility_uid = JSON.parse(data);
+            let ct_files = (0, file_helper_1.readdirSync)(ctPath);
+            if (ct_field_visibility_uid && ct_field_visibility_uid != 'undefined') {
+                for (const ele of ct_field_visibility_uid) {
+                    if (ct_files.indexOf(ele + '.json') > -1) {
+                        let schema = require(path.resolve(ctPath, ele));
+                        // await field_rules_update(schema)
+                        let fieldRuleLength = schema.field_rules.length;
+                        for (let k = 0; k < fieldRuleLength; k++) {
+                            let fieldRuleConditionLength = schema.field_rules[k].conditions.length;
+                            for (let i = 0; i < fieldRuleConditionLength; i++) {
+                                if (schema.field_rules[k].conditions[i].operand_field === 'reference') {
+                                    let entryMapperPath = path.resolve(importConfig.data, 'mapper', 'entries');
+                                    let entryUidMapperPath = path.join(entryMapperPath, 'uid-mapping.json');
+                                    let fieldRulesValue = schema.field_rules[k].conditions[i].value;
+                                    let fieldRulesArray = fieldRulesValue.split('.');
+                                    let updatedValue = [];
+                                    for (const element of fieldRulesArray) {
+                                        let splitedFieldRulesValue = element;
+                                        let oldUid = (0, file_helper_1.readFileSync)(path.join(entryUidMapperPath));
+                                        if (oldUid.hasOwnProperty(splitedFieldRulesValue)) {
+                                            updatedValue.push(oldUid[splitedFieldRulesValue]);
+                                        }
+                                        else {
+                                            updatedValue.push(element);
+                                        }
+                                    }
+                                    schema.field_rules[k].conditions[i].value = updatedValue.join('.');
+                                }
+                            }
+                            const stackAPIClient = client.stack({
+                                api_key: importConfig.target_stack,
+                                management_token: importConfig.management_token,
+                            });
+                            let ctObj = stackAPIClient.contentType(schema.uid);
+                            Object.assign(ctObj, _.cloneDeep(schema));
+                            ctObj
+                                .update()
+                                .then(() => {
+                                return resolve('');
+                            })
+                                .catch((error) => {
+                                return reject(error);
+                            });
+                        }
+                    }
+                }
+            }
+        })
+            .catch(reject);
+    });
+};
+exports.field_rules_update = field_rules_update;
+const getConfig = () => {
+    return config;
+};
+exports.getConfig = getConfig;
+const formatError = (error) => {
+    try {
+        if (typeof error === 'string') {
+            error = JSON.parse(error);
+        }
+        else {
+            error = JSON.parse(error.message);
+        }
+    }
+    catch (e) { }
+    let message = (error === null || error === void 0 ? void 0 : error.errorMessage) || (error === null || error === void 0 ? void 0 : error.error_message) || (error === null || error === void 0 ? void 0 : error.message) || error;
+    if (error && 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 = (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;
+const validateBranch = async (stackAPIClient, config, branch) => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const data = await stackAPIClient.branch(branch).fetch();
+            if (data && typeof data === 'object') {
+                if (data.error_message) {
+                    (0, logger_1.log)(config, chalk_1.default.red(data.error_message), 'error');
+                    (0, logger_1.log)(config, chalk_1.default.red('No branch found with the name ' + branch), 'error');
+                    reject({ message: 'No branch found with the name ' + branch, error: data.error_message });
+                }
+                else {
+                    resolve(data);
+                }
+            }
+            else {
+                reject({ message: 'No branch found with the name ' + branch, error: {} });
+            }
+        }
+        catch (error) {
+            (0, logger_1.log)(config, chalk_1.default.red('No branch found with the name ' + branch), 'error');
+            reject({ message: 'No branch found with the name ' + branch, error });
+        }
+    });
+};
+exports.validateBranch = validateBranch;

package/lib/utils/content-type-helper.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Content type utiles
+ * schema template
+ * remove reference fields
+ * suppress mandatory fields
+ */
+export declare const schemaTemplate: {
+    content_type: {
+        title: string;
+        uid: string;
+        schema: ({
+            display_name: string;
+            uid: string;
+            data_type: string;
+            field_metadata: {
+                _default: boolean;
+            };
+            unique: boolean;
+            mandatory: boolean;
+            multiple: boolean;
+        } | {
+            display_name: string;
+            uid: string;
+            data_type: string;
+            field_metadata: {
+                _default: boolean;
+            };
+            unique: boolean;
+            multiple: boolean;
+            mandatory?: undefined;
+        })[];
+        options: {
+            title: string;
+            publishable: boolean;
+            is_page: boolean;
+            singleton: boolean;
+            sub_title: string[];
+            url_pattern: string;
+            url_prefix: string;
+        };
+    };
+};
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+export declare const suppressSchemaReference: (schema: any, flag: any) => void;
+export declare const removeReferenceFields: (schema: any, flag: {
+    supressed: boolean;
+}, stackAPIClient: any) => Promise<boolean | void>;

package/lib/utils/content-type-helper.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Content type utiles
+ * schema template
+ * remove reference fields
+ * suppress mandatory fields
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeReferenceFields = exports.suppressSchemaReference = exports.schemaTemplate = void 0;
+exports.schemaTemplate = {
+    content_type: {
+        title: 'Seed',
+        uid: '',
+        schema: [
+            {
+                display_name: 'Title',
+                uid: 'title',
+                data_type: 'text',
+                field_metadata: {
+                    _default: true,
+                },
+                unique: false,
+                mandatory: true,
+                multiple: false,
+            },
+            {
+                display_name: 'URL',
+                uid: 'url',
+                data_type: 'text',
+                field_metadata: {
+                    _default: true,
+                },
+                unique: false,
+                multiple: false,
+            },
+        ],
+        options: {
+            title: 'title',
+            publishable: true,
+            is_page: true,
+            singleton: false,
+            sub_title: ['url'],
+            url_pattern: '/:title',
+            url_prefix: '/',
+        },
+    },
+};
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+const suppressSchemaReference = function (schema, flag) {
+    for (var i in schema) {
+        if (schema[i].data_type === 'group' || schema[i].data_type === 'global_field') {
+            (0, exports.suppressSchemaReference)(schema[i].schema, flag);
+        }
+        else if (schema[i].data_type === 'blocks') {
+            for (var block in schema[i].blocks) {
+                (0, exports.suppressSchemaReference)(schema[i].blocks[block].schema, flag);
+            }
+        }
+        else if (schema[i].data_type === 'reference') {
+            flag.references = true;
+        }
+        else if (schema[i].data_type === 'json' && schema[i].field_metadata.rich_text_type) {
+            flag.jsonRte = true;
+            if (schema[i].field_metadata.embed_entry === true)
+                flag.jsonRteEmbeddedEntries = true;
+        }
+        if ((schema[i].hasOwnProperty('mandatory') && schema[i].mandatory) ||
+            (schema[i].hasOwnProperty('unique') && schema[i].unique)) {
+            if (schema[i].uid !== 'title') {
+                schema[i].unique = false;
+                schema[i].mandatory = false;
+                flag.suppressed = true;
+            }
+        }
+    }
+};
+exports.suppressSchemaReference = suppressSchemaReference;
+const removeReferenceFields = async function (schema, flag = { supressed: false }, stackAPIClient) {
+    for (let i = 0; i < schema.length; i++) {
+        if (schema[i].data_type === 'group') {
+            await (0, exports.removeReferenceFields)(schema[i].schema, flag, stackAPIClient);
+        }
+        else if (schema[i].data_type === 'blocks') {
+            for (var block in schema[i].blocks) {
+                await (0, exports.removeReferenceFields)(schema[i].blocks[block].schema, flag, stackAPIClient);
+            }
+        }
+        else if (schema[i].data_type === 'reference' || schema[i].reference_to) {
+            flag.supressed = true;
+            // Check if content-type exists
+            // If exists, then no change should be required.
+            let isContentTypeError = false;
+            for (let j = 0; j < schema[i].reference_to.length; j++) {
+                try {
+                    await stackAPIClient.contentType(schema[i].reference_to[j]).fetch();
+                }
+                catch (error) {
+                    // Else warn and modify the schema object.
+                    isContentTypeError = true;
+                    console.warn(`Content-type ${schema[i].reference_to[j]} does not exist. Removing the field from schema`);
+                }
+            }
+            if (isContentTypeError) {
+                schema.splice(i, 1);
+                --i;
+                if (schema.length < 1) {
+                    schema.push({
+                        data_type: 'text',
+                        display_name: 'dummyTest',
+                        uid: 'dummy_test',
+                        field_metadata: {
+                            description: '',
+                            default_value: '',
+                            version: 3,
+                        },
+                        format: '',
+                        error_messages: {
+                            format: '',
+                        },
+                        multiple: false,
+                        mandatory: false,
+                        unique: false,
+                        non_localizable: false,
+                    });
+                }
+            }
+            return true;
+        }
+        else if (
+        // handling entry references in json rte
+        schema[i].data_type === 'json' &&
+            schema[i].field_metadata.rich_text_type &&
+            schema[i].field_metadata.embed_entry &&
+            schema[i].reference_to.length > 1) {
+            flag.supressed = true;
+            schema[i].reference_to = ['sys_assets'];
+            return true;
+        }
+    }
+};
+exports.removeReferenceFields = removeReferenceFields;

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

@@ -0,0 +1,4 @@
+/**
+ * Entries lookup
+ */
+export declare const lookupEntries: (data: any, mappedUids: string[], uidMapperPath: string) => any;