@contentstack/cli-cm-import 1.5.8 → 1.5.9

package/README.md

@@ -47,7 +47,7 @@ $ npm install -g @contentstack/cli-cm-import
 $ csdx COMMAND
 running command...
 $ csdx (--version)
-@contentstack/cli-cm-import/1.5.8 linux-x64 node-v16.20.0
+@contentstack/cli-cm-import/1.5.9 linux-x64 node-v16.20.0
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.5.8",
+  "version": "1.5.9",
   "commands": {
     "cm:stacks:import": {
       "id": "cm:stacks:import",

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@contentstack/cli-cm-import",
   "description": "Contentstack CLI plugin to import content into stack",
-  "version": "1.5.8",
+  "version": "1.5.9",
   "author": "Contentstack",
   "bugs": "https://github.com/contentstack/cli/issues",
   "dependencies": {
-    "@contentstack/cli-command": "^1.2.8",
-    "@contentstack/cli-utilities": "^1.4.4",
+    "@contentstack/cli-command": "^1.2.9",
+    "@contentstack/cli-utilities": "^1.4.5",
     "@oclif/config": "^1.18.3",
     "big-json": "^3.2.0",
     "bluebird": "^3.7.2",

package/src/app.js

@@ -47,13 +47,13 @@ exports.initial = (configData) => {
             importRes.then(resolve).catch(reject);
           })
           .catch((error) => {
-            addlogs(config, `Failed to import contents ${util.formatError(error)}`, 'error');
+            addlogs(config, `Failed to import contents. ${util.formatError(error)}`, 'error');
             reject(error);
             process.exit(1);
           });
       } else {
         let filename = path.basename(config.data);
-        addlogs(config, chalk.red(filename + ' Folder does not Exist'), 'error');
+        addlogs(config, chalk.red(`'${filename}' Folder does not exist'`), 'error');
       }
     };
 
@@ -95,7 +95,7 @@ let singleImport = async (APIClient, stackAPIClient, moduleName, types, config)
         }
       }
       if (!(importResponse && importResponse.empty)) {
-        addlogs(config, moduleName + ' imported successfully!', 'success');
+        addlogs(config, `Module '${moduleName}' imported successfully!`, 'success');
       }
       addlogs(config, 'The log for this is stored at ' + path.join(config.oldPath, 'logs', 'import'), 'success');
       return true;
@@ -103,9 +103,9 @@ let singleImport = async (APIClient, stackAPIClient, moduleName, types, config)
       addlogs(config, 'Please provide valid module name.', 'error');
     }
   } catch (error) {
-    addlogs(config, 'Failed to migrate ' + moduleName, 'error');
+    addlogs(config, `Failed to migrate '${moduleName}'`, 'error');
     addlogs(config, util.formatError(error), 'error');
-    addlogs(config, 'The log for this is stored at ' + path.join(config.oldPath, 'logs', 'import'), 'error');
+    addlogs(config, `The log for this is stored at '${path.join(config.oldPath, 'logs', 'import')}'`, 'error');
   }
 };
 
@@ -148,15 +148,11 @@ let allImport = async (APIClient, stackAPIClient, config, types) => {
   } catch (error) {
     addlogs(
       config,
-      chalk.red(
-        'Failed to migrate stack: ' +
-          (config.destinationStackName || config.target_stack) +
-          '. Please check error logs for more info',
-      ),
+      `Failed to migrate stack '${(config.destinationStackName || config.target_stack)}'. Please check error logs for more info`,
       'error',
     );
     addlogs(config, util.formatError(error), 'error');
-    addlogs(config, 'The log for this is stored at ' + path.join(config.oldPath, 'logs', 'import'), 'error');
+    addlogs(config, `The log for this is stored at '${path.join(config.oldPath, 'logs', 'import')}'`, 'error');
   }
 };
 
@@ -193,8 +189,8 @@ const validateIfBranchExist = async (stackAPIClient, config, branch) => {
         .catch((_err) => {});
       if (data && typeof data === 'object') {
         if (data.error_message) {
-          addlogs(config, chalk.red(data.error_message), 'error');
-          addlogs(config, chalk.red('No branch found with the name ' + branch), 'error');
+          addlogs(config, data.error_message, 'error');
+          addlogs(config, `No branch found with the name '${branch}`, 'error');
           reject({ message: 'No branch found with the name ' + branch, error: error_message });
         } else {
           resolve(data);
@@ -203,7 +199,7 @@ const validateIfBranchExist = async (stackAPIClient, config, branch) => {
         reject({ message: 'No branch found with the name ' + branch, error: {} });
       }
     } catch (error) {
-      addlogs(config, chalk.red('No branch found with the name ' + branch), 'error');
+      addlogs(config, `No branch found with the name '${branch}`, 'error');
       reject({ message: 'No branch found with the name ' + branch, error });
     }
   });

package/src/commands/cm/stacks/import.js

@@ -1,7 +1,7 @@
 const _ = require('lodash');
 const defaultConfig = require('../../../config/default');
 const { Command } = require('@contentstack/cli-command');
-const { flags, printFlagDeprecation, isAuthenticated } = require('@contentstack/cli-utilities');
+const { flags, printFlagDeprecation, isAuthenticated, cliux } = require('@contentstack/cli-utilities');
 const {
   configWithMToken,
   parameterWithMToken,
@@ -51,7 +51,7 @@ class ImportCommand extends Command {
 
           result.then(resolve).catch(reject);
         } else {
-          console.log('management Token is not present please add managment token first');
+          cliux.print(`error: management Token is not present please add managment token first`, {color: 'red'});
         }
       } else if (isAuthenticated()) {
         let result;
@@ -66,7 +66,7 @@ class ImportCommand extends Command {
 
         result.then(resolve).catch(reject);
       } else {
-        console.log('Login or provide the alias for management token');
+        cliux.print(`error: Login or provide the alias for management token`, {color: 'red'});
       }
     });
   }

package/src/lib/import/assets.js

@@ -97,7 +97,7 @@ module.exports = class ImportAssets {
                     // hence, upload each asset with its version
                     if (self.config.versioning) {
                       return self.uploadVersionedAssets(assetUid, currentAssetFolderPath).catch(function (error) {
-                        addlogs(self.config, (chalk.red('Asset upload failed \n' + error), 'error'));
+                        addlogs(self.config, `Asset upload failed.\n ${error}`, 'error');
                       });
                     }
 
@@ -111,7 +111,7 @@ module.exports = class ImportAssets {
                       } else {
                         addlogs(
                           self.config,
-                          self.assets[assetUid].parent_uid + " parent_uid was not found! Thus, setting it as 'null'",
+                          `'${self.assets[assetUid].parent_uid}' parent_uid was not found! Thus, setting it as 'null'`,
                           'error',
                         );
                       }
@@ -135,13 +135,13 @@ module.exports = class ImportAssets {
                         // log them onto /mapper/assets/success.json
                       })
                       .catch(function (error) {
-                        addlogs(self.config, chalk.red('Asset upload failed \n' + error, 'error'));
+                        addlogs(self.config, `Asset upload failed.\n ${error}`, 'error');
                         return error;
                         // asset failed to upload
                         // log them onto /mapper/assets/fail.json
                       });
                   }
-                  addlogs(self.config, currentAssetFolderPath + ' does not exist!', 'error');
+                  addlogs(self.config, `'${currentAssetFolderPath}' does not exist!`, 'error');
                 },
                 { concurrency: self.assetConfig.assetBatchLimit },
               ).then(function () {
@@ -195,7 +195,8 @@ module.exports = class ImportAssets {
         } else {
           addlogs(
             self.config,
-            (lastVersion.parent_uid + " parent_uid was not found! Thus, setting it as 'null'", 'error'),
+            `'${lastVersion.parent_uid}' parent_uid was not found! Thus, setting it as 'null'`,
+            'error'
           );
           versionedAssetMetadata.forEach(function (assetMetadata) {
             assetMetadata.parent_uid = null;
@@ -247,7 +248,7 @@ module.exports = class ImportAssets {
         .catch(function (error) {
           // failed to upload asset
           // write it on fail logs, but do not stop the process
-          addlogs(self.config, chalk.red('Failed to upload asset\n' + error), 'error');
+          addlogs(self.config, `Failed to upload asset\n ${error}`, 'error');
           return resolve();
         });
     });
@@ -377,7 +378,7 @@ module.exports = class ImportAssets {
             .catch(function (err) {
               let error = JSON.parse(err.message);
               if (error.errors.authorization || error.errors.api_key) {
-                addlogs(self.config, chalk.red('Api_key or management_token is not valid'), 'error');
+                addlogs(self.config, 'Api_key or management_token is not valid', 'error');
                 return reject(error);
               }
 
@@ -483,7 +484,7 @@ module.exports = class ImportAssets {
               error = { errorMessage: err.message };
             }
 
-            addlogs(self.config, chalk.red('Asset ' + assetUid + ' not published, ' + error.errorMessage), 'error');
+            addlogs(self.config, `Asset '${assetUid}' not published, ${error.errorMessage}`, 'error');
             return reject(err);
           }
 

package/src/lib/import/content-types.js

@@ -106,12 +106,24 @@ class ContentTypesImport {
         try {
           await fileHelper.writeFile(path.join(this.contentTypesFolderPath, 'field_rules_uid.json'), this.fieldRules);
         } catch (error) {
-          addlogs(this.importConfig, `Failed to write field rules ${formatError(error)}`, 'success');
+          addlogs(this.importConfig, `Failed to write field rules ${formatError(error)}`, 'error');
         }
       }
 
       addlogs(this.importConfig, chalk.green('Content types imported successfully'), 'success');
     } catch (error) {
+      let message_content_type = "";
+      if (error.request !== undefined && JSON.parse(error.request.data).content_type !== undefined) {
+        if (JSON.parse(error.request.data).content_type.uid) {
+          message_content_type =
+            ' Update the content type with content_type_uid  - ' + JSON.parse(error.request.data).content_type.uid;
+        } else if (JSON.parse(error.request.data).content_type.title) {
+          message_content_type =
+            ' Update the content type with content_type_title  - ' + JSON.parse(error.request.data).content_type.title;
+        }
+        error.errorMessage =  error.errorMessage + message_content_type;
+      }
+      addlogs(this.importConfig, formatError(error.errorMessage), 'error');
       addlogs(this.importConfig, formatError(error), 'error');
       throw new Error('Failed to import content types');
     }
@@ -149,7 +161,7 @@ class ContentTypesImport {
     const contentTypeResponse = this.stackAPIClient.contentType(contentType.uid);
     Object.assign(contentTypeResponse, cloneDeep(contentType));
     await contentTypeResponse.update();
-    addlogs(this.importConfig, contentType.uid + ' updated with references', 'success');
+    addlogs(this.importConfig, `'${contentType.uid}' updated with references`, 'success');
   }
 
   async updateGlobalFields(uid) {
@@ -167,15 +179,15 @@ class ContentTypesImport {
         // Improve write the updated global fields once all updates are completed
         this.existingGlobalFields.splice(existingGlobalField, 1, globalField);
         await fileHelper.writeFile(this.globalFieldMapperFolderPath, this.existingGlobalFields).catch((error) => {
-          addlogs(this.importConfig, `failed to write updated the global field ${uid} ${formatError(error)}`);
+          addlogs(this.importConfig, `failed to write updated the global field '${uid}'. ${formatError(error)}`);
         });
-        addlogs(this.importConfig, `Updated the global field ${uid} with content type references `);
+        addlogs(this.importConfig, `Updated the global field '${uid}' with content type references `);
         return true;
       } catch (error) {
-        addlogs(this.importConfig, `failed to update the global field ${uid} ${formatError(error)}`);
+        addlogs(this.importConfig, `failed to update the global field '${uid}'. ${formatError(error)}`);
       }
     } else {
-      addlogs(this.importConfig, `Global field ${uid} does not exist, and hence failed to update.`);
+      addlogs(this.importConfig, `Global field '${uid}' does not exist, and hence failed to update.`);
     }
   }
 

package/src/lib/import/custom-roles.js

@@ -49,7 +49,7 @@ module.exports = class ImportCustomRoles {
       mkdirp.sync(customRolesMapperPath);
 
       if (!self.customRoles) {
-        addlogs(self.config, chalk.white('No custom-roles found'), 'error');
+        addlogs(self.config, chalk.white('No custom-roles found'), 'info');
         return;
       }
       self.customRolesUids = Object.keys(self.customRoles);
@@ -71,7 +71,7 @@ module.exports = class ImportCustomRoles {
         if (uid in self.customRolesUidMapper) {
           addlogs(
             self.config,
-            chalk.white(`The custom-role ${customRole.name} already exists. Skipping it to avoid duplicates!`),
+            chalk.white(`The custom-role '${customRole.name}' already exists. Skipping it to avoid duplicates!`),
             'success',
           );
           continue;
@@ -98,14 +98,13 @@ module.exports = class ImportCustomRoles {
           self.fails.push(customRole);
 
           if (((error && error.errors && error.errors.name) || '').includes('is not a unique.')) {
-            addlogs(self.config, chalk.red(`${customRole.name} role already exists`), 'info');
+            addlogs(self.config, `custom-role '${customRole.name}' already exists`, 'error');
           } else {
             if (!(error && error.errors && error.errors.name)) {
-              addlogs(self.config, chalk.red(`custom-role: ${customRole.name} already exists`), 'error');
+              addlogs(self.config, `custom-role '${customRole.name}' already exists`, 'error');
             } else {
-              addlogs(self.config, chalk.red(`custom-role: ${customRole.name} failed`), 'error');
+              addlogs(self.config, `custom-role '${customRole.name}' failed`, 'error');
             }
-
             addlogs(self.config, formatError(error), 'error');
           }
         }
@@ -113,7 +112,7 @@ module.exports = class ImportCustomRoles {
       addlogs(self.config, chalk.green('Custom-roles have been imported successfully!'), 'success');
     } catch (error) {
       helper.writeFileSync(customRolesFailsPath, self.fails);
-      addlogs(self.config, chalk.red('Custom-roles import failed'), 'error');
+      addlogs(self.config, 'Custom-roles import failed', 'error');
       addlogs(self.config, formatError(error), 'error');
 
       throw error;

package/src/lib/import/entries.js

@@ -103,7 +103,7 @@ module.exports = class ImportEntries {
             }
           }
         } catch (error) {
-          addlogs(this.config, `Failed to read the content types to import entries ${util.formatError(error)}`);
+          addlogs(this.config, `Failed to read the content types to import entries ${util.formatError(error)}`, 'error');
           process.exit(0);
         }
       }
@@ -148,7 +148,7 @@ module.exports = class ImportEntries {
                 (self.config.hasOwnProperty('onlylocales') && self.config.onlylocales.indexOf(lang) !== -1) ||
                 !self.config.hasOwnProperty('onlylocales')
               ) {
-                addlogs(self.config, `Starting to create entries ${lang} locale`, 'info');
+                addlogs(self.config, `Starting to create entries '${lang}' locale`, 'info');
                 await self.createEntries(lang, mappedAssetUids, mappedAssetUrls);
                 addlogs(self.config, 'Entries created successfully', 'info');
                 try {
@@ -156,7 +156,8 @@ module.exports = class ImportEntries {
                 } catch (error) {
                   addlogs(
                     self.config,
-                    `Failed get the existing entries to update the mapper ${util.formatError(error)}, 'error`,
+                    `Failed get the existing entries to update the mapper ${util.formatError(error)}`,
+                    'error',
                   );
                 }
                 addlogs(self.config, 'Starting to update entries with references', 'info');
@@ -164,7 +165,7 @@ module.exports = class ImportEntries {
                 addlogs(self.config, "Successfully imported '" + lang + "' entries!", 'success');
                 counter++;
               } else {
-                addlogs(self.config, lang + ' has not been configured for import, thus skipping it', 'success');
+                addlogs(self.config,`'${lang}' has not been configured for import, thus skipping it`, 'success');
                 counter++;
               }
             },
@@ -189,7 +190,8 @@ module.exports = class ImportEntries {
                   } catch (error) {
                     addlogs(
                       self.config,
-                      `Failed to update the field rules for content type ${schema.uid} ${util.formatError(error)}`,
+                      `Failed to update the field rules for content type '${schema.uid}' ${util.formatError(error)}`,
+                      'error'
                     );
                   }
                 }
@@ -254,7 +256,7 @@ module.exports = class ImportEntries {
                 'success',
               );
             } else {
-              addlogs(this.config, `Creating entries for content type ${ctUid} in language ${lang} ...`, 'success');
+              addlogs(this.config, `Creating entries for content type '${ctUid}' in language '${lang}' ...`, 'success');
               for (let eUid in entries) {
                 if (eUid) {
                   try {
@@ -281,7 +283,7 @@ module.exports = class ImportEntries {
                       self.installedExtensions,
                     );
                   } catch (error) {
-                    addlogs(this.config, 'Failed to update entry while creating entry id ' + eUid);
+                    addlogs(this.config, `Failed to update entry while creating entry id '${eUid}'`, 'error');
                     addlogs(this.config, util.formatError(error), 'error');
                   }
                 }
@@ -479,13 +481,7 @@ module.exports = class ImportEntries {
           } else {
             addlogs(
               this.config,
-              chalk.white(
-                'Unable to find entry file path for ' +
-                  ctUid +
-                  " content type!\nThe file '" +
-                  eFilePath +
-                  "' does not exist!",
-              ),
+              `Unable to find entry file path for '${ctUid}' content type!\nThe file '${eFilePath}' does not exist!`,
               'error',
             );
           }
@@ -499,7 +495,7 @@ module.exports = class ImportEntries {
           return resolve();
         })
         .catch((error) => {
-          addlogs(this.config, chalk.red("Failed to create entries in '" + lang + "' language"), 'error');
+          addlogs(this.config, `Failed to create entries in '${lang}' language`, 'error');
           return reject(error);
         });
     });
@@ -568,7 +564,7 @@ module.exports = class ImportEntries {
           // map failed reference uids @mapper/language/unmapped-uids.json
           let refUidMapperPath = path.join(this.entryMapperPath, lang);
 
-          addlogs(this.config, 'staring to update the entry for reposting');
+          addlogs(this.config, 'Starting to update the entry for reposting');
 
           entries = _.map(entries, (entry) => {
             try {
@@ -598,6 +594,7 @@ module.exports = class ImportEntries {
               addlogs(
                 this.config,
                 `Failed to update the entry ${uid} references while reposting ${util.formatError(error)}`,
+                'error'
               );
             }
           });
@@ -645,14 +642,7 @@ module.exports = class ImportEntries {
                       .catch((error) => {
                         addlogs(
                           this.config,
-                          chalk.red(
-                            'Entry Uid: ' +
-                              entry.uid +
-                              ' of Content Type: ' +
-                              ctUid +
-                              ' failed to update in locale: ' +
-                              lang,
-                          ),
+                          `Entry Uid '${entry.uid}' of Content Type '${ctUid}' failed to update in locale '${lang}'`,
                           'error',
                         );
 
@@ -685,7 +675,7 @@ module.exports = class ImportEntries {
                 })
                 .catch((error) => {
                   // error while executing entry in batch
-                  addlogs(this.config, chalk.red('Failed re-post entries at batch no: ' + (index + 1)), 'error');
+                  addlogs(this.config, `Failed re-post entries at batch no: '${(index + 1)}`, 'error');
                   addlogs(this.config, util.formatError(error), 'error');
                   // throw error;
                 });
@@ -706,7 +696,8 @@ module.exports = class ImportEntries {
               // error while updating entries with references
               addlogs(
                 this.config,
-                chalk.red(`Failed re-post entries of content type ${ctUid} locale ${lang}`, 'error'),
+                `Failed re-post entries of content type ${ctUid} locale ${lang}`,
+                 'error',
               );
               addlogs(this.config, util.formatError(error), 'error');
               // throw error;
@@ -723,7 +714,7 @@ module.exports = class ImportEntries {
         })
         .catch((error) => {
           // error while updating entry references
-          addlogs(this.config, chalk.red('Failed to re post entries in ' + lang + ' language'), 'error');
+          addlogs(this.config, `Failed to re post entries in '${lang}' language`, 'error');
           return reject(error);
         });
     });
@@ -792,9 +783,9 @@ module.exports = class ImportEntries {
             .then((_updatedcontentType) => {
               // empty function
             })
-            .catch((_error) => {
+            .catch((error) => {
               addlogs(this.config, util.formatError(error), 'error');
-              reject(`Failed suppress content type ${schema.uid} reference fields`);
+              reject(`Failed suppress content type '${schema.uid}' reference fields`);
             });
           // update 5 content types at a time
         },
@@ -890,7 +881,7 @@ module.exports = class ImportEntries {
                     return resolveContentType();
                   })
                   .catch((error) => {
-                    addlogs(this.config, chalk.red('Failed to re-update ' + schema.uid), 'error');
+                    addlogs(this.config, `Failed to re-update '${schema.uid}`, 'error');
                     addlogs(this.config, error, 'error');
                     return rejectContentType(error);
                   });
@@ -951,7 +942,7 @@ module.exports = class ImportEntries {
               addlogs(this.config, 'Removed bugged entry from master ' + JSON.stringify(entry), 'success');
             })
             .catch((error) => {
-              addlogs(this.config, chalk.red('Failed to remove bugged entry from master language'), 'error');
+              addlogs(this.config, 'Failed to remove bugged entry from master language', 'error');
               addlogs(this.config, util.formatError(error), 'error');
             });
         },
@@ -976,6 +967,7 @@ module.exports = class ImportEntries {
         .catch((error) => {
           // error while removing bugged entries from stack
           addlogs(this.config, util.formatError(error), 'error');
+          addlogs(this.config, error, 'error');
         });
     });
   }
@@ -1057,7 +1049,7 @@ module.exports = class ImportEntries {
               } else {
                 return;
               }
-
+              
               return Promise.map(
                 batches,
                 async (batch, index) => {
@@ -1097,7 +1089,7 @@ module.exports = class ImportEntries {
                                 // addlogs(this.config, 'Entry ' + eUid + ' published successfully in ' + ctUid + ' content type', 'success')
                                 addlogs(
                                   this.config,
-                                  'Entry ' + eUid + ' published successfully in ' + ctUid + ' content type',
+                                  `Entry '${eUid}' published successfully in '${ctUid}' content type`,
                                   'success',
                                 );
                                 return resolveEntryPublished(result);
@@ -1106,7 +1098,8 @@ module.exports = class ImportEntries {
                               .catch((err) => {
                                 addlogs(
                                   this.config,
-                                  `failed to publish entry ${eUid} content type ${ctUid} ${util.formatError(err)}`,
+                                  `failed to publish entry '${eUid}' content type '${ctUid}' ${util.formatError(err)}`,
+                                  'error'
                                 );
                                 return resolveEntryPublished('');
                               });
@@ -1126,6 +1119,7 @@ module.exports = class ImportEntries {
                     .catch((error) => {
                       // error while executing entry in batch
                       addlogs(this.config, util.formatError(error), 'error');
+                      addlogs(this.config, error, 'error');
                     });
                 },
                 {
@@ -1134,10 +1128,10 @@ module.exports = class ImportEntries {
               )
                 .then(() => {
                   // addlogs(this.config, 'Entries published successfully in ' + ctUid + ' content type', 'success')
-                  addlogs('Entries published successfully in ' + ctUid + ' content type');
+                  addlogs(this.config, `Entries published successfully in '${ctUid}' content type`, 'info');
                 })
                 .catch((error) => {
-                  addlogs(this.config, `failed to publish entry in content type ${ctUid} ${util.formatError(error)}`);
+                  addlogs(this.config, `failed to publish entry in content type '${ctUid}' ${util.formatError(error)}`, 'error');
                 });
             },
             {
@@ -1149,7 +1143,7 @@ module.exports = class ImportEntries {
               // addlogs('Published entries successfully in ' +);
             })
             .catch((error) => {
-              addlogs(`Failed to publish few entries in ${lang} ${util.formatError(error)}`);
+              addlogs(this.config, `Failed to publish few entries in '${lang}' ${util.formatError(error)}`, 'error');
             });
         },
         {
@@ -1160,7 +1154,7 @@ module.exports = class ImportEntries {
           return resolve();
         })
         .catch((error) => {
-          addlogs(`Failed to publish entries ${util.formatError(error)}`);
+          addlogs(this.config,`Failed to publish entries. ${util.formatError(error)}`, 'error');
         });
     });
   }

package/src/lib/import/environments.js

@@ -71,13 +71,11 @@ module.exports = class ImportEnvironments {
                 let error = JSON.parse(err.message);
 
                 if (error.errors.name) {
-                  addlogs(self.config, chalk.white("Environment: '" + env.name + "' already exists"), 'error');
+                  addlogs(self.config, `Environment '${env.name}' already exists`, 'error');
                 } else {
                   addlogs(
                     config,
-                    chalk.white(
-                      "Environment: '" + env.name + "' failed to be import\n " + JSON.stringify(error.errors),
-                    ),
+                    `Environment '${env.name}' failed to be import\n ${JSON.stringify(error.errors)}`,
                     'error',
                   );
                 }
@@ -86,7 +84,7 @@ module.exports = class ImportEnvironments {
             // the environment has already been created
             addlogs(
               config,
-              chalk.white("The environment: '" + env.name + "' already exists. Skipping it to avoid duplicates!"),
+              `The environment ${env.name} already exists. Skipping it to avoid duplicates!`,
               'success',
             );
           }
@@ -100,7 +98,7 @@ module.exports = class ImportEnvironments {
         })
         .catch(function (error) {
           helper.writeFileSync(envFailsPath, self.fails);
-          addlogs(self.config, chalk.red(`Failed to import environment ${formatError(error)}`), 'error');
+          addlogs(self.config, `Failed to import environment, ${formatError(error)}`, 'error');
           reject(error);
         });
     });

package/src/lib/import/extensions.js

@@ -69,11 +69,11 @@ module.exports = class ImportExtensions {
                 let error = JSON.parse(err.message);
                 self.fails.push(ext);
                 if (error.errors.title) {
-                  addlogs(self.config, chalk.white("Extension: '" + ext.title + "' already exists"), 'success');
+                  addlogs(self.config, `Extension '${ext.title}' already exists`, 'error');
                 } else {
                   addlogs(
                     config,
-                    chalk.white("Extension: '" + ext.title + "' failed to be import\n " + JSON.stringify(error.errors)),
+                    chalk.white(`Extension '${ext.title}' failed to be import\n ${JSON.stringify(error.errors)}`),
                     'error',
                   );
                 }
@@ -100,7 +100,7 @@ module.exports = class ImportExtensions {
         .catch(function (error) {
           // error while importing extensions
           helper.writeFileSync(extFailsPath, self.fails);
-          addlogs(self.config, chalk.red(`Extension import failed ${util.formatError(error)}`), 'error');
+          addlogs(self.config, `Extension import failed ${util.formatError(error)}`, 'error');
           reject(error);
         });
     });

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

@@ -65,11 +65,11 @@ module.exports = class ImportGlobalFields {
       let snipUids = Object.keys(self.globalfields);
       return Promise.map(
         snipUids,
-        function (snipUid) {
+        async function (snipUid) {
           let flag = { supressed: false };
           let snip = self.globalfields[snipUid];
           extension_supress(snip.schema, self.config.preserveStackVersion, self.installedExtensions);
-          removeReferenceFields(snip.schema, flag);
+          await removeReferenceFields(snip.schema, flag, self.stackAPIClient);
 
           if (flag.supressed) {
             // eslint-disable-next-line no-undef
@@ -96,9 +96,9 @@ module.exports = class ImportGlobalFields {
                 let error = JSON.parse(err.message);
                 if (error.errors.title) {
                   // eslint-disable-next-line no-undef
-                  addlogs(self.config, chalk.white(snip.uid + ' globalfield already exists'), 'error');
+                  addlogs(self.config, `Globalfield '${snip.uid} already exists'`, 'error');
                 } else {
-                  addlogs(self.config, chalk.red(`Globalfield failed to import ${formatError(error)}`), 'error');
+                  addlogs(self.config, `Globalfield failed to import ${formatError(error)}`, 'error');
                 }
 
                 self.fails.push(snip);
@@ -119,7 +119,7 @@ module.exports = class ImportGlobalFields {
           // globalfields have imported successfully
           helper.writeFileSync(globalfieldsSuccessPath, self.success);
           helper.writeFileSync(globalFieldsPending, _globalField_pending);
-          addlogs(self.config, chalk.green('globalfields have been imported successfully!'), 'success');
+          addlogs(self.config, chalk.green('Globalfields have been imported successfully!'), 'success');
           return resolve();
         })
         .catch(function (err) {
@@ -127,7 +127,7 @@ module.exports = class ImportGlobalFields {
           // error while importing globalfields
           addlogs(self.config, err, 'error');
           helper.writeFileSync(globalfieldsFailsPath, self.fails);
-          addlogs(self.config, chalk.red('globalfields import failed'), 'error');
+          addlogs(self.config, `Globalfields import failed. ${formatError(err)}`, 'error');
           return reject(error);
         });
     });

package/src/lib/import/labels.js

@@ -76,16 +76,16 @@ module.exports = class ImportLabels {
               .catch(function (error) {
                 self.fails.push(label);
                 if (error.errors.name) {
-                  addlogs(self.config, chalk.red("Label: '" + label.name + "'  already exist"), 'error');
+                  addlogs(self.config,`Label '${label.name}' already exist`, 'error');
                 } else {
-                  addlogs(self.config, chalk.red("Label: '" + label.name + "' failed to be imported\n"), 'error');
+                  addlogs(self.config,`Label '${label.name}' failed to be imported\n`, 'error');
                 }
               });
           } else {
             // the label has already been created
             addlogs(
               self.config,
-              chalk.white("The label: '" + label.name + "' already exists. Skipping it to avoid duplicates!"),
+              chalk.white(`The label '${label.name}' already exists. Skipping it to avoid duplicates!'`),
               'success',
             );
           }
@@ -104,7 +104,7 @@ module.exports = class ImportLabels {
               return resolve();
             })
             .catch(function (error) {
-              addlogs(self.config, chalk.red(`Failed to import label ${formatError(error)}`), 'error');
+              addlogs(self.config, `Failed to import label, ${formatError(error)}`, 'error');
               // eslint-disable-next-line no-console
               return reject(error);
             });
@@ -113,7 +113,7 @@ module.exports = class ImportLabels {
           // error while importing labels
           helper.writeFileSync(labelUidMapperPath, self.labelUidMapper);
           helper.writeFileSync(labelFailsPath, self.fails);
-          addlogs(self.config, chalk.red(`Failed to import label ${formatError(error)}`), 'error');
+          addlogs(self.config, `Failed to import label, ${formatError(error)}`, 'error');
           return reject(error);
         });
     });

package/src/lib/import/locales.js

@@ -91,16 +91,20 @@ module.exports = class ImportLanguages {
               .catch(function (err) {
                 let error = JSON.parse(err.message);
                 if (error.hasOwnProperty('errorCode') && error.errorCode === 247) {
-                  addlogs(self.config, error.errors.code[0], 'success');
+                  if(error.errors.code){
+                    addlogs(self.config, error.errors.code[0], 'error');
+                  }else{
+                    addlogs(self.config, err, 'error');
+                  }
                   return err;
                 }
                 self.fails.push(lang);
-                addlogs(self.config, chalk.red("Language: '" + lang.code + "' failed to be import\n"), 'error');
+                addlogs(self.config, `Language '${lang.code}' failed to import\n`, 'error');
                 addlogs(self.config, formatError(err), 'error');
               });
           } else {
             // the language has already been created
-            addlogs(self.config, chalk.yellow("The language: '" + lang.code + "' already exists."), 'error');
+            addlogs(self.config, `The language '${lang.code}' already exists.`, 'error');
           }
 
           // import 2 languages at a time
@@ -124,8 +128,7 @@ module.exports = class ImportLanguages {
         .catch(function (error) {
           // error while importing languages
           helper.writeFileSync(langFailsPath, self.fails);
-          addlogs(self.config, chalk.red('Language import failed'), 'error');
-          addlogs(self.config, formatError(error), 'error');
+          addlogs(self.config, `Language import failed. ${formatError(error)}`, 'error');
           reject('failed to import Languages');
         });
     });

package/src/lib/import/marketplace-apps.js

@@ -515,16 +515,21 @@ module.exports = class ImportMarketplaceApps {
       return Promise.resolve();
     }
 
-    return this.httpClient
-      .put(`${this.developerHubBaseUrl}/installations/${uid}`, payload)
-      .then(({ data }) => {
-        if (data.message) {
-          log(this.config, formatError(data.message), 'success');
-        } else {
-          log(this.config, `${app.manifest.name} app config updated successfully.!`, 'success');
-        }
-      })
-      .catch((error) => log(this.config, formatError(error), 'error'));
+    let installation = this.client
+    .organization(this.config.org_uid)
+    .app(app.manifest.uid)
+    .installation(uid)
+
+    installation = Object.assign(installation, payload)
+
+    return installation
+    .update()
+    .then(async data => {
+      if (data) {
+        log(this.config, `${app.manifest.name} app config updated successfully.!`, 'success');
+      }
+    })
+    .catch((error) => log(this.config, formatError(error), 'error'))
   }
 
   validateAppName(name) {

package/src/lib/import/webhooks.js

@@ -80,7 +80,7 @@ module.exports = class ImportWebhooks {
                 self.fails.push(web);
                 addlogs(
                   self.config,
-                  chalk.red("Webhooks: '" + web.name + "' failed to be import\n" + formatError(error)),
+                  `Webhooks '${web.name}' failed to be import.\n ${formatError(error)}`,
                   'error',
                 );
               });
@@ -105,7 +105,7 @@ module.exports = class ImportWebhooks {
         .catch(function (error) {
           // error while importing environments
           helper.writeFileSync(webFailsPath, self.fails);
-          addlogs(self.config, chalk.red('Webhooks import failed'), 'error');
+          addlogs(self.config, `Webhooks import failed. ${formatError(error)}`, 'error');
           return reject(error);
         });
     });

package/src/lib/import/workflows.js

@@ -97,7 +97,7 @@ module.exports = class importWorkflows {
                 } catch (error) {
                   addlogs(
                     self.config,
-                    chalk.red('Error while importing workflows roles. ' + formatError(error)),
+                    `Error while importing workflows roles. ${formatError(error)}`,
                     'error',
                   );
                   reject({ message: 'Error while importing workflows roles' });
@@ -128,24 +128,22 @@ module.exports = class importWorkflows {
               .catch(function (error) {
                 self.fails.push(workflow);
                 if (error.errors.name) {
-                  addlogs(self.config, chalk.red("workflow: '" + workflow.name + "'  already exist"), 'error');
+                  addlogs(self.config, `workflow ${workflow.name} already exist`, 'error');
                 } else if (error.errors['workflow_stages.0.users']) {
                   addlogs(
                     self.config,
-                    chalk.red(
-                      "Failed to import Workflows as you've specified certain roles in the Stage transition and access rules section. We currently don't import roles to the stack.",
-                    ),
+                    "Failed to import Workflows as you've specified certain roles in the Stage transition and access rules section. We currently don't import roles to the stack.",
                     'error',
                   );
                 } else {
-                  addlogs(self.config, chalk.red("workflow: '" + workflow.name + "'  failed"), 'error');
+                  addlogs(self.config, `workflow ${workflow.name} failed.`, 'error');
                 }
               });
           } else {
             // the workflow has already been created
             addlogs(
               self.config,
-              chalk.white("The Workflows: '" + workflow.name + "' already exists. Skipping it to avoid duplicates!"),
+              chalk.white( `The Workflows ${workflow.name} already exists. Skipping it to avoid duplicates!`),
               'success',
             );
           }
@@ -160,8 +158,7 @@ module.exports = class importWorkflows {
         })
         .catch(function (error) {
           helper.writeFileSync(workflowFailsPath, self.fails);
-          addlogs(self.config, chalk.red('Workflows import failed'), 'error');
-          addlogs(self.config, formatError(error), 'error');
+          addlogs(self.config, `Workflows import failed. ${formatError(error)}`, 'error');
           return reject(error);
         });
     });

package/src/lib/util/log.js

@@ -91,7 +91,10 @@ function init(_logPath) {
     errorLogger = winston.createLogger({
       transports: [
         new winston.transports.File(errorTransport),
-        new winston.transports.Console({ level: 'error', format: winston.format.simple() }),
+        new winston.transports.Console({
+          level: 'error',
+          format: winston.format.combine(winston.format.colorize({ all: true, colors:{ error: 'red'} }), winston.format.simple()),
+        }),
       ],
       levels: { error: 0 },
     });

package/src/lib/util/removeReferenceFields.js

@@ -1,7 +1,7 @@
-var _ = require('lodash');
+const _ = require('lodash');
 
 /* eslint-disable no-empty */
-var removeReferenceFields = (module.exports = function (schema, flag) {
+const removeReferenceFields = (module.exports = async function (schema, flag, stackAPIClient) {
   for (let i = 0; i < schema.length; i++) {
     if (schema[i].data_type === 'group') {
       removeReferenceFields(schema[i].schema, flag);
@@ -11,27 +11,41 @@ var removeReferenceFields = (module.exports = function (schema, flag) {
       }
     } else if (schema[i].data_type === 'reference') {
       flag.supressed = true;
-      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: {
+      // 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: '',
-          },
-          multiple: false,
-          mandatory: false,
-          unique: false,
-          non_localizable: false,
-        });
+            error_messages: {
+              format: '',
+            },
+            multiple: false,
+            mandatory: false,
+            unique: false,
+            non_localizable: false,
+          });
+        }
       }
     } else if( // handling entry references in json rte
       schema[i].data_type === 'json'