@contentstack/cli-cm-import 1.25.0 → 1.26.0

package/lib/utils/asset-helper.js

@@ -20,6 +20,7 @@ function validate(req) {
 const uploadAssetHelper = function (config, req, fsPath, RETRY) {
     return new bluebird_1.default(function (resolve, reject) {
         try {
+            cli_utilities_1.log.debug(`Starting asset upload helper for path: ${fsPath}`);
             (0, cli_utilities_1.managementSDKClient)(config)
                 .then((APIClient) => {
                 validate(req);
@@ -27,8 +28,10 @@ const uploadAssetHelper = function (config, req, fsPath, RETRY) {
                     RETRY = 1;
                 }
                 else if (RETRY > MAX_RETRY_LIMIT) {
+                    cli_utilities_1.log.debug(`Max retry limit exceeded for asset upload: ${fsPath}`);
                     return reject(new Error('Max retry limit exceeded!'));
                 }
+                cli_utilities_1.log.debug(`Uploading asset (attempt ${RETRY}/${MAX_RETRY_LIMIT}): ${fsPath}`);
                 req.upload = fsPath;
                 const stackAPIClient = APIClient.stack({
                     api_key: config.target_stack,
@@ -38,16 +41,21 @@ const uploadAssetHelper = function (config, req, fsPath, RETRY) {
                     .asset()
                     .create(req)
                     .then((response) => {
+                    cli_utilities_1.log.debug(`Asset upload successful: ${fsPath}`);
                     return resolve(response);
                 })
                     .catch((error) => {
+                    cli_utilities_1.log.error(`Asset upload failed: ${fsPath}`);
                     return reject(error);
                 });
             })
-                .catch(reject);
+                .catch((error) => {
+                reject(error);
+            });
         }
         catch (error) {
             debug(error);
+            cli_utilities_1.log.debug('Unexpected error in uploadAssetHelper');
             return reject(error);
         }
     });
@@ -55,6 +63,7 @@ const uploadAssetHelper = function (config, req, fsPath, RETRY) {
 exports.uploadAssetHelper = uploadAssetHelper;
 // get assets object
 const lookupAssets = function (data, mappedAssetUids, mappedAssetUrls, assetUidMapperPath, installedExtensions) {
+    var _a, _b, _c;
     if (!_.has(data, 'entry') ||
         !_.has(data, 'content_type') ||
         !_.isPlainObject(mappedAssetUids) ||
@@ -62,6 +71,7 @@ const lookupAssets = function (data, mappedAssetUids, mappedAssetUrls, assetUidM
         typeof assetUidMapperPath !== 'string') {
         throw new Error('Invalid inputs for lookupAssets!');
     }
+    cli_utilities_1.log.debug(`Starting asset lookup for entry: ${(_a = data.entry) === null || _a === void 0 ? void 0 : _a.uid}, content type: ${(_b = data.content_type) === null || _b === void 0 ? void 0 : _b.uid}`);
     let parent = [];
     let assetUids = [];
     let assetUrls = [];
@@ -114,20 +124,24 @@ const lookupAssets = function (data, mappedAssetUids, mappedAssetUrls, assetUidM
             }
             else if (schema[i].data_type === 'json' && schema[i].field_metadata.extension) {
                 if (installedExtensions && installedExtensions[schema[i].extension_uid]) {
+                    cli_utilities_1.log.debug(`Mapping extension UID: ${schema[i].extension_uid} to ${installedExtensions[schema[i].extension_uid]}`);
                     schema[i].extension_uid = installedExtensions[schema[i].extension_uid];
                 }
             }
         }
     };
     function findAssetIdsFromJsonCustomFields(entryObj, ctSchema) {
+        cli_utilities_1.log.debug('Processing JSON custom fields for asset references');
         ctSchema.map((row) => {
             if (row.data_type === 'json') {
                 if (entryObj[row.uid] && row.field_metadata.extension && row.field_metadata.is_asset) {
                     if (installedExtensions && installedExtensions[row.extension_uid]) {
+                        cli_utilities_1.log.debug(`Mapping extension UID in custom field: ${row.extension_uid}`);
                         row.extension_uid = installedExtensions[row.extension_uid];
                     }
                     if (entryObj[row.uid].metadata && entryObj[row.uid].metadata.extension_uid) {
                         if (installedExtensions && installedExtensions[entryObj[row.uid].metadata.extension_uid]) {
+                            cli_utilities_1.log.debug(`Mapping metadata extension UID: ${entryObj[row.uid].metadata.extension_uid}`);
                             entryObj[row.uid].metadata.extension_uid = installedExtensions[entryObj[row.uid].metadata.extension_uid];
                         }
                     }
@@ -137,15 +151,18 @@ const lookupAssets = function (data, mappedAssetUids, mappedAssetUrls, assetUidM
         });
     }
     function findAssetIdsFromHtmlRte(entryObj, ctSchema) {
+        cli_utilities_1.log.debug('Extracting asset UIDs from HTML RTE fields');
         const regex = /<img asset_uid=\\"([^"]+)\\"/g;
         let match;
         const entry = JSON.stringify(entryObj);
         while ((match = regex.exec(entry)) !== null) {
             assetUids.push(match[1]);
         }
+        cli_utilities_1.log.debug(`Found ${assetUids.length} asset UIDs in HTML RTE`);
     }
     function findAssetIdsFromJsonRte(entryObj, ctSchema) {
         var _a;
+        cli_utilities_1.log.debug('Processing JSON RTE fields for asset references');
         for (const element of ctSchema) {
             switch (element.data_type) {
                 case 'blocks': {
@@ -233,6 +250,7 @@ const lookupAssets = function (data, mappedAssetUids, mappedAssetUrls, assetUidM
     updateFileFields(data.entry, data, null, mappedAssetUids, matchedUids, unmatchedUids, mappedAssetUrls);
     assetUids = _.uniq(assetUids);
     assetUrls = _.uniq(assetUrls);
+    cli_utilities_1.log.debug(`Found ${assetUids.length} unique asset UIDs and ${assetUrls.length} unique asset URLs`);
     let entry = JSON.stringify(data.entry);
     assetUrls.forEach(function (assetUrl) {
         let mappedAssetUrl = mappedAssetUrls[assetUrl];
@@ -256,6 +274,7 @@ const lookupAssets = function (data, mappedAssetUids, mappedAssetUrls, assetUidM
         }
     });
     if (matchedUids.length) {
+        cli_utilities_1.log.debug(`Successfully mapped ${matchedUids.length} asset UIDs`);
         let matchedAssetUids = helper.readFileSync(path.join(assetUidMapperPath, 'matched-asset-uids.json'));
         matchedAssetUids = matchedAssetUids || {};
         if (matchedAssetUids.hasOwnProperty(data.content_type.uid)) {
@@ -271,6 +290,7 @@ const lookupAssets = function (data, mappedAssetUids, mappedAssetUrls, assetUidM
         }
     }
     if (unmatchedUids.length) {
+        cli_utilities_1.log.warn(`Found ${unmatchedUids.length} unmatched asset UIDs`);
         let unmatchedAssetUids = helper.readFileSync(path.join(assetUidMapperPath, 'unmatched-asset-uids.json'));
         unmatchedAssetUids = unmatchedAssetUids || {};
         if (unmatchedAssetUids.hasOwnProperty(data.content_type.uid)) {
@@ -284,6 +304,7 @@ const lookupAssets = function (data, mappedAssetUids, mappedAssetUrls, assetUidM
         helper.writeFile(path.join(assetUidMapperPath, 'unmatched-asset-uids.json'));
     }
     if (unmatchedUrls.length) {
+        cli_utilities_1.log.warn(`Found ${unmatchedUrls.length} unmatched asset URLs`);
         let unmatchedAssetUrls = helper.readFileSync(path.join(assetUidMapperPath, 'unmatched-asset-urls.json'));
         unmatchedAssetUrls = unmatchedAssetUrls || {};
         if (unmatchedAssetUrls.hasOwnProperty(data.content_type.uid)) {
@@ -297,6 +318,7 @@ const lookupAssets = function (data, mappedAssetUids, mappedAssetUrls, assetUidM
         helper.writeFile(path.join(assetUidMapperPath, 'unmatched-asset-urls.json'));
     }
     if (matchedUrls.length) {
+        cli_utilities_1.log.debug(`Successfully mapped ${matchedUrls.length} asset URLs`);
         let matchedAssetUrls = helper.readFileSync(path.join(assetUidMapperPath, 'matched-asset-urls.json'));
         matchedAssetUrls = matchedAssetUrls || {};
         if (matchedAssetUrls.hasOwnProperty(data.content_type.uid)) {
@@ -309,6 +331,7 @@ const lookupAssets = function (data, mappedAssetUids, mappedAssetUrls, assetUidM
         }
         helper.writeFile(path.join(assetUidMapperPath, 'matched-asset-urls.json'));
     }
+    cli_utilities_1.log.debug(`Asset lookup completed for entry: ${(_c = data.entry) === null || _c === void 0 ? void 0 : _c.uid}`);
     return JSON.parse(entry);
 };
 exports.lookupAssets = lookupAssets;

package/lib/utils/backup-handler.js

@@ -6,13 +6,16 @@ const fs_extra_1 = require("fs-extra");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
 const index_1 = require("./index");
 async function backupHandler(importConfig) {
+    cli_utilities_1.log.debug('Starting backup handler process');
     if (importConfig.hasOwnProperty('useBackedupDir')) {
+        cli_utilities_1.log.debug(`Using existing backup directory: ${importConfig.useBackedupDir}`);
         return importConfig.useBackedupDir;
     }
     let backupDirPath;
     const subDir = isSubDirectory(importConfig);
     if (subDir) {
         backupDirPath = path.resolve((0, cli_utilities_1.sanitizePath)(importConfig.contentDir), '..', '_backup_' + Math.floor(Math.random() * 1000));
+        cli_utilities_1.log.debug(`Detected subdirectory configuration, creating backup at: ${backupDirPath}`);
         if (importConfig.createBackupDir) {
             cli_utilities_1.cliux.print(`Warning!!! Provided backup directory path is a sub directory of the content directory, Cannot copy to a sub directory. Hence new backup directory created - ${backupDirPath}`, {
                 color: 'yellow',
@@ -22,15 +25,20 @@ async function backupHandler(importConfig) {
     else {
         // NOTE: If the backup folder's directory is provided, create it at that location; otherwise, the default path (working directory).
         backupDirPath = path.join(process.cwd(), '_backup_' + Math.floor(Math.random() * 1000));
+        cli_utilities_1.log.debug(`Using default backup directory: ${backupDirPath}`);
         if (importConfig.createBackupDir) {
+            cli_utilities_1.log.debug(`Custom backup directory specified: ${importConfig.createBackupDir}`);
             if (index_1.fileHelper.fileExistsSync(importConfig.createBackupDir)) {
+                cli_utilities_1.log.debug(`Removing existing backup directory: ${importConfig.createBackupDir}`);
                 index_1.fileHelper.removeDirSync(importConfig.createBackupDir);
             }
+            cli_utilities_1.log.debug(`Creating backup directory: ${importConfig.createBackupDir}`);
             index_1.fileHelper.makeDirectory(importConfig.createBackupDir);
             backupDirPath = importConfig.createBackupDir;
         }
     }
     if (backupDirPath) {
+        cli_utilities_1.log.debug(`Starting content copy to backup directory: ${backupDirPath}`);
         cli_utilities_1.cliux.print('Copying content to the backup directory...');
         return new Promise((resolve, reject) => {
             return (0, fs_extra_1.copy)(importConfig.contentDir, backupDirPath, (error) => {
@@ -38,6 +46,7 @@ async function backupHandler(importConfig) {
                     (0, index_1.trace)(error, 'error', true);
                     return reject(error);
                 }
+                cli_utilities_1.log.debug(`Successfully created backup at: ${backupDirPath}`);
                 resolve(backupDirPath);
             });
         });
@@ -50,12 +59,17 @@ exports.default = backupHandler;
  * @returns
  */
 function isSubDirectory(importConfig) {
+    cli_utilities_1.log.debug('Checking if backup directory is a subdirectory');
     const parent = importConfig.contentDir;
     const child = importConfig.createBackupDir ? importConfig.createBackupDir : process.cwd();
     const relative = path.relative(parent, child);
+    cli_utilities_1.log.debug(`Parent directory: ${parent}, Child directory: ${child}, Relative path: ${relative}`);
     if (relative) {
-        return !relative.startsWith('..') && !path.isAbsolute(relative);
+        const isSubDir = !relative.startsWith('..') && !path.isAbsolute(relative);
+        cli_utilities_1.log.debug(`Is subdirectory: ${isSubDir}`);
+        return isSubDir;
     }
     // true if both parent and child have same path
+    cli_utilities_1.log.debug('Parent and child directories are the same');
     return true;
 }

package/lib/utils/common-helper.js

@@ -12,8 +12,6 @@ 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;
@@ -26,8 +24,9 @@ const initialization = (configData) => {
 };
 exports.initialization = initialization;
 const validateConfig = (importConfig) => {
+    cli_utilities_1.log.debug('Validating import configuration');
     if (importConfig.email && importConfig.password && !importConfig.target_stack) {
-        (0, logger_1.log)(importConfig, chalk_1.default.red('Kindly provide api_token'), 'error');
+        cli_utilities_1.log.debug('Target stack API token is required when using email/password authentication');
         return 'error';
     }
     else if (!importConfig.email &&
@@ -35,29 +34,34 @@ const validateConfig = (importConfig) => {
         !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');
+        cli_utilities_1.log.debug('Authentication credentials missing - either management token or email/password required');
         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');
+        cli_utilities_1.log.debug('Email and password required for stack version preservation');
         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');
+        cli_utilities_1.log.debug('Both email and password must be provided together');
         return 'error';
     }
 };
 exports.validateConfig = validateConfig;
 const buildAppConfig = (importConfig) => {
+    cli_utilities_1.log.debug('Building application configuration with defaults');
     importConfig = _.merge(config_1.default, importConfig);
     return importConfig;
 };
 exports.buildAppConfig = buildAppConfig;
 const sanitizeStack = (importConfig) => {
     if (typeof importConfig.preserveStackVersion !== 'boolean' || !importConfig.preserveStackVersion) {
+        cli_utilities_1.log.debug('Stack version preservation not enabled, skipping sanitization');
+        return Promise.resolve();
+    }
+    if (importConfig.management_token) {
+        cli_utilities_1.log.info('Skipping stack version sanitization: Operation is not supported when using a management token.');
         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);
@@ -65,20 +69,22 @@ const sanitizeStack = (importConfig) => {
             if (stackDetails.data && stackDetails.data.stack && stackDetails.data.stack.settings) {
                 const newStackVersion = stackDetails.data.stack.settings.version;
                 const newStackDate = new Date(newStackVersion).toString();
+                cli_utilities_1.log.debug(`New stack version: ${newStackVersion} (${newStackDate})`);
                 const stackFilePath = path.join((0, cli_utilities_1.sanitizePath)(importConfig.data), (0, cli_utilities_1.sanitizePath)(importConfig.modules.stack.dirName), (0, cli_utilities_1.sanitizePath)(importConfig.modules.stack.fileName));
+                cli_utilities_1.log.debug(`Reading stack file from: ${stackFilePath}`);
                 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();
+                cli_utilities_1.log.debug(`Old stack version: ${oldStackDetails.settings.version} (${oldStackDate})`);
                 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');
+                cli_utilities_1.log.debug('Updating stack version to preserve compatibility');
                 return httpClient
                     .put(`https://${importConfig.host}/v3${importConfig.apis.stacks}settings/set-version`, {
                     stack_settings: {
@@ -86,7 +92,7 @@ const sanitizeStack = (importConfig) => {
                     },
                 })
                     .then((response) => {
-                    (0, logger_1.log)(importConfig, `Stack version preserved successfully!\n${JSON.stringify(response.data)}`, 'success');
+                    cli_utilities_1.log.info(`Stack version preserved successfully!\n${JSON.stringify(response.data)}`);
                 });
             }
             throw new Error(`Unexpected stack details ${stackDetails && JSON.stringify(stackDetails.data)}`);
@@ -98,30 +104,39 @@ const sanitizeStack = (importConfig) => {
 };
 exports.sanitizeStack = sanitizeStack;
 const masterLocalDetails = (stackAPIClient) => {
+    cli_utilities_1.log.debug('Fetching master locale details');
     return stackAPIClient
         .locale()
         .query({ query: { fallback_locale: null } })
         .find()
-        .then(({ items }) => items[0]);
+        .then(({ items }) => {
+        var _a;
+        cli_utilities_1.log.debug(`Found master locale: ${(_a = items[0]) === null || _a === void 0 ? void 0 : _a.code}`);
+        return items[0];
+    });
 };
 exports.masterLocalDetails = masterLocalDetails;
 const field_rules_update = (importConfig, ctPath) => {
     return new Promise(async (resolve, reject) => {
+        cli_utilities_1.log.debug('Starting field rules update process');
         let client = await (0, cli_utilities_1.managementSDKClient)(config);
         (0, file_helper_1.readFile)(path.join(ctPath + '/field_rules_uid.json'))
             .then(async (data) => {
+            cli_utilities_1.log.debug('Processing field rules UID mapping');
             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') {
+                cli_utilities_1.log.debug(`Processing ${ct_field_visibility_uid.length} content types with field rules`);
                 for (const ele of ct_field_visibility_uid) {
                     if (ct_files.indexOf(ele + '.json') > -1) {
+                        cli_utilities_1.log.debug(`Updating field rules for content type: ${ele}`);
                         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') {
+                                    cli_utilities_1.log.debug(`Processing reference field rule condition`);
                                     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;
@@ -131,9 +146,11 @@ const field_rules_update = (importConfig, ctPath) => {
                                         let splitedFieldRulesValue = element;
                                         let oldUid = (0, file_helper_1.readFileSync)(path.join(entryUidMapperPath));
                                         if (oldUid.hasOwnProperty(splitedFieldRulesValue)) {
+                                            cli_utilities_1.log.debug(`Mapped UID: ${splitedFieldRulesValue} -> ${oldUid[splitedFieldRulesValue]}`);
                                             updatedValue.push(oldUid[splitedFieldRulesValue]);
                                         }
                                         else {
+                                            cli_utilities_1.log.debug(`No mapping found for UID: ${splitedFieldRulesValue}`);
                                             updatedValue.push(element);
                                         }
                                     }
@@ -153,9 +170,11 @@ const field_rules_update = (importConfig, ctPath) => {
                             ctObj
                                 .update()
                                 .then(() => {
+                                cli_utilities_1.log.debug(`Successfully updated field rules for content type: ${schema.uid}`);
                                 return resolve('');
                             })
                                 .catch((error) => {
+                                cli_utilities_1.log.error(`Failed to update field rules for content type: ${schema.uid}`);
                                 return reject(error);
                             });
                         }
@@ -163,7 +182,9 @@ const field_rules_update = (importConfig, ctPath) => {
                 }
             }
         })
-            .catch(reject);
+            .catch((error) => {
+            reject(error);
+        });
     });
 };
 exports.field_rules_update = field_rules_update;
@@ -200,7 +221,9 @@ const formatError = (error) => {
 };
 exports.formatError = formatError;
 const executeTask = (tasks = [], handler, options) => {
+    cli_utilities_1.log.debug(`Executing ${tasks.length} tasks with concurrency: ${options.concurrency}`);
     if (typeof handler !== 'function') {
+        cli_utilities_1.log.error('Invalid handler function provided for task execution');
         throw new Error('Invalid handler');
     }
     const { concurrency = 1 } = options;
@@ -212,24 +235,26 @@ const executeTask = (tasks = [], handler, options) => {
 exports.executeTask = executeTask;
 const validateBranch = async (stackAPIClient, config, branch) => {
     return new Promise(async (resolve, reject) => {
+        cli_utilities_1.log.debug(`Validating branch: ${branch}`);
         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');
+                    cli_utilities_1.log.error(`Branch validation failed: ${data.error_message}`);
                     reject({ message: 'No branch found with the name ' + branch, error: data.error_message });
                 }
                 else {
+                    cli_utilities_1.log.info(`Branch validation successful: ${branch}`);
                     resolve(data);
                 }
             }
             else {
+                cli_utilities_1.log.error(`Invalid branch data received for: ${branch}`);
                 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');
+            cli_utilities_1.log.error(`No branch found with the name: ${branch}`);
             reject({ message: 'No branch found with the name ' + branch, error });
         }
     });

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

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateFieldRules = exports.removeReferenceFields = exports.suppressSchemaReference = exports.schemaTemplate = void 0;
+const cli_utilities_1 = require("@contentstack/cli-utilities");
 exports.schemaTemplate = {
     content_type: {
         title: 'Seed',
@@ -52,70 +53,91 @@ exports.schemaTemplate = {
  */
 const suppressSchemaReference = function (schema, flag) {
     var _a, _b, _c, _d;
+    cli_utilities_1.log.debug('Starting schema reference suppression process');
     for (var i in schema) {
         if (schema[i].data_type === 'group' || schema[i].data_type === 'global_field') {
+            cli_utilities_1.log.debug(`Processing ${schema[i].data_type} field: ${schema[i].uid}`);
             (0, exports.suppressSchemaReference)(schema[i].schema, flag);
         }
         else if (schema[i].data_type === 'blocks') {
+            cli_utilities_1.log.debug(`Processing blocks field: ${schema[i].uid}`);
             for (var block in schema[i].blocks) {
                 (0, exports.suppressSchemaReference)(schema[i].blocks[block].schema, flag);
             }
         }
         else if (schema[i].data_type === 'reference') {
+            cli_utilities_1.log.debug(`Found reference field: ${schema[i].uid}`);
             flag.references = true;
         }
         else if (schema[i].data_type === 'json' && ((_b = (_a = schema[i]) === null || _a === void 0 ? void 0 : _a.field_metadata) === null || _b === void 0 ? void 0 : _b.rich_text_type)) {
+            cli_utilities_1.log.debug(`Found JSON RTE field: ${schema[i].uid}`);
             flag.jsonRte = true;
-            if (schema[i].field_metadata.embed_entry === true)
+            if (schema[i].field_metadata.embed_entry === true) {
+                cli_utilities_1.log.debug(`JSON RTE field has embedded entries: ${schema[i].uid}`);
                 flag.jsonRteEmbeddedEntries = true;
+            }
         }
         else if (schema[i].data_type === 'text' && ((_d = (_c = schema[i]) === null || _c === void 0 ? void 0 : _c.field_metadata) === null || _d === void 0 ? void 0 : _d.rich_text_type)) {
+            cli_utilities_1.log.debug(`Found text RTE field: ${schema[i].uid}`);
             flag.rte = true;
-            if (schema[i].field_metadata.embed_entry === true)
+            if (schema[i].field_metadata.embed_entry === true) {
+                cli_utilities_1.log.debug(`Text RTE field has embedded entries: ${schema[i].uid}`);
                 flag.rteEmbeddedEntries = true;
+            }
         }
         if ((schema[i].hasOwnProperty('mandatory') && schema[i].mandatory) ||
             (schema[i].hasOwnProperty('unique') && schema[i].unique)) {
             if (schema[i].uid !== 'title') {
+                cli_utilities_1.log.debug(`Suppressing mandatory/unique constraints for field: ${schema[i].uid}`);
                 schema[i].unique = false;
                 schema[i].mandatory = false;
                 flag.suppressed = true;
             }
         }
     }
+    cli_utilities_1.log.debug('Schema reference suppression completed');
 };
 exports.suppressSchemaReference = suppressSchemaReference;
 const removeReferenceFields = async function (schema, flag = { supressed: false }, stackAPIClient) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    cli_utilities_1.log.debug('Starting reference field removal process');
     if (schema === null || schema === void 0 ? void 0 : schema.length) {
         for (let i = 0; i < schema.length; i++) {
             if (schema[i].data_type === 'group') {
+                cli_utilities_1.log.debug(`Processing group field: ${schema[i].uid}`);
                 await (0, exports.removeReferenceFields)(schema[i].schema, flag, stackAPIClient);
             }
             else if (schema[i].data_type === 'blocks') {
+                cli_utilities_1.log.debug(`Processing blocks field: ${schema[i].uid}`);
                 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') {
+                cli_utilities_1.log.debug(`Processing reference field: ${schema[i].uid}`);
                 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 {
+                        cli_utilities_1.log.debug(`Checking if content type exists: ${schema[i].reference_to[j]}`);
                         await stackAPIClient.contentType(schema[i].reference_to[j]).fetch();
+                        cli_utilities_1.log.debug(`Content type exists: ${schema[i].reference_to[j]}`);
                     }
                     catch (error) {
                         // Else warn and modify the schema object.
                         isContentTypeError = true;
+                        cli_utilities_1.log.warn(`Content type does not exist: ${schema[i].reference_to[j]}`);
                         console.warn(`Content-type ${schema[i].reference_to[j]} does not exist. Removing the field from schema`);
                     }
                 }
                 if (isContentTypeError) {
+                    cli_utilities_1.log.debug(`Removing reference field due to missing content types: ${schema[i].uid}`);
                     schema.splice(i, 1);
                     --i;
                     if (schema.length < 1) {
+                        cli_utilities_1.log.debug('Adding dummy field to prevent empty schema');
                         schema.push({
                             data_type: 'text',
                             display_name: 'dummyTest',
@@ -143,6 +165,7 @@ const removeReferenceFields = async function (schema, flag = { supressed: false
                 schema[i].field_metadata.allow_json_rte &&
                 schema[i].field_metadata.embed_entry &&
                 schema[i].reference_to.length > 1) {
+                cli_utilities_1.log.debug(`Restricting JSON RTE field to assets only: ${schema[i].uid}`);
                 flag.supressed = true;
                 schema[i].reference_to = ['sys_assets'];
             }
@@ -152,6 +175,7 @@ const removeReferenceFields = async function (schema, flag = { supressed: false
                 ((_b = (_a = schema[i]) === null || _a === void 0 ? void 0 : _a.field_metadata) === null || _b === void 0 ? void 0 : _b.rich_text_type) &&
                 ((_d = (_c = schema[i]) === null || _c === void 0 ? void 0 : _c.field_metadata) === null || _d === void 0 ? void 0 : _d.embed_entry) &&
                 ((_f = (_e = schema[i]) === null || _e === void 0 ? void 0 : _e.reference_to) === null || _f === void 0 ? void 0 : _f.length) > 1) {
+                cli_utilities_1.log.debug(`Restricting JSON RTE field to assets only: ${schema[i].uid}`);
                 flag.supressed = true;
                 schema[i].reference_to = ['sys_assets'];
             }
@@ -161,21 +185,26 @@ const removeReferenceFields = async function (schema, flag = { supressed: false
                 ((_h = (_g = schema[i]) === null || _g === void 0 ? void 0 : _g.field_metadata) === null || _h === void 0 ? void 0 : _h.rich_text_type) &&
                 ((_k = (_j = schema[i]) === null || _j === void 0 ? void 0 : _j.field_metadata) === null || _k === void 0 ? void 0 : _k.embed_entry) &&
                 ((_m = (_l = schema[i]) === null || _l === void 0 ? void 0 : _l.reference_to) === null || _m === void 0 ? void 0 : _m.length) >= 1) {
+                cli_utilities_1.log.debug(`Restricting text RTE field to assets only: ${schema[i].uid}`);
                 flag.supressed = true;
                 schema[i].reference_to = ['sys_assets'];
             }
         }
     }
+    cli_utilities_1.log.debug('Reference field removal process completed');
 };
 exports.removeReferenceFields = removeReferenceFields;
 const updateFieldRules = function (contentType) {
+    cli_utilities_1.log.debug(`Starting field rules update for content type: ${contentType.uid}`);
     const fieldDataTypeMap = {};
     for (let i = 0; i < contentType.schema.length; i++) {
         const field = contentType.schema[i];
         fieldDataTypeMap[field.uid] = field.data_type;
     }
+    cli_utilities_1.log.debug(`Created field data type mapping for ${Object.keys(fieldDataTypeMap).length} fields`);
     const fieldRules = [...contentType.field_rules];
     let len = fieldRules.length;
+    let removedRules = 0;
     // Looping backwards as we need to delete elements as we move.
     for (let i = len - 1; i >= 0; i--) {
         const conditions = fieldRules[i].conditions;
@@ -183,13 +212,17 @@ const updateFieldRules = function (contentType) {
         for (let j = 0; j < conditions.length; j++) {
             const field = conditions[j].operand_field;
             if (fieldDataTypeMap[field] === 'reference') {
+                cli_utilities_1.log.debug(`Found reference field in rule condition: ${field}`);
                 isReference = true;
             }
         }
         if (isReference) {
+            cli_utilities_1.log.debug(`Removing field rule with reference condition`);
             fieldRules.splice(i, 1);
+            removedRules++;
         }
     }
+    cli_utilities_1.log.debug(`Field rules update completed. Removed ${removedRules} rules with reference conditions`);
     return fieldRules;
 };
 exports.updateFieldRules = updateFieldRules;