@contentstack/cli-variants 1.2.2 → 1.3.2

package/lib/import/audiences.js

@@ -14,7 +14,7 @@ const fs_1 = require("fs");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
 const utils_1 = require("../utils");
 class Audiences extends utils_1.PersonalizationAdapter {
-    constructor(config, log = console.log) {
+    constructor(config) {
         const conf = {
             config,
             baseURL: config.modules.personalize.baseURL[config.region.name],
@@ -22,7 +22,6 @@ class Audiences extends utils_1.PersonalizationAdapter {
         };
         super(Object.assign(config, conf));
         this.config = config;
-        this.log = log;
         this.personalizeConfig = this.config.modules.personalize;
         this.audienceConfig = this.personalizeConfig.audiences;
         this.attributeConfig = this.personalizeConfig.attributes;
@@ -31,6 +30,7 @@ class Audiences extends utils_1.PersonalizationAdapter {
         this.audiencesUidMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.audienceMapperDirPath), 'uid-mapping.json');
         this.attributesMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.mapperDirPath), (0, cli_utilities_1.sanitizePath)(this.attributeConfig.dirName), 'uid-mapping.json');
         this.audiencesUidMapper = {};
+        this.config.context.module = 'audiences';
     }
     /**
      * The function asynchronously imports audiences from a JSON file and creates them in the system.
@@ -38,40 +38,53 @@ class Audiences extends utils_1.PersonalizationAdapter {
     import() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
-            this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Audiences' }), 'info');
             yield this.init();
             yield utils_1.fsUtil.makeDirectory(this.audienceMapperDirPath);
+            cli_utilities_1.log.debug(`Created mapper directory: ${this.audienceMapperDirPath}`, this.config.context);
             const { dirName, fileName } = this.audienceConfig;
             const audiencesPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.data), (0, cli_utilities_1.sanitizePath)(this.personalizeConfig.dirName), (0, cli_utilities_1.sanitizePath)(dirName), (0, cli_utilities_1.sanitizePath)(fileName));
+            cli_utilities_1.log.debug(`Checking for audiences file: ${audiencesPath}`, this.config.context);
             if ((0, fs_1.existsSync)(audiencesPath)) {
                 try {
                     const audiences = utils_1.fsUtil.readFile(audiencesPath, true);
+                    cli_utilities_1.log.info(`Found ${audiences.length} audiences to import`, this.config.context);
                     const attributesUid = utils_1.fsUtil.readFile(this.attributesMapperPath, true) || {};
+                    cli_utilities_1.log.debug(`Loaded ${Object.keys(attributesUid).length} attribute mappings for audience processing`, this.config.context);
                     for (const audience of audiences) {
                         let { name, definition, description, uid } = audience;
+                        cli_utilities_1.log.debug(`Processing audience: ${name} (${uid})`, this.config.context);
                         try {
                             //check whether reference attributes exists or not
                             if ((_a = definition.rules) === null || _a === void 0 ? void 0 : _a.length) {
+                                cli_utilities_1.log.debug(`Processing ${definition.rules.length} definition rules for audience: ${name}`, this.config.context);
                                 definition.rules = (0, utils_1.lookUpAttributes)(definition.rules, attributesUid);
+                                cli_utilities_1.log.debug(`Processed definition rules, remaining rules: ${definition.rules.length}`, this.config.context);
                             }
+                            else {
+                                cli_utilities_1.log.debug(`No definition rules found for audience: ${name}`, this.config.context);
+                            }
+                            cli_utilities_1.log.debug(`Creating audience: ${name}`, this.config.context);
                             const audienceRes = yield this.createAudience({ definition, name, description });
                             //map old audience uid to new audience uid
                             //mapper file is used to check whether audience created or not before creating experience
                             this.audiencesUidMapper[uid] = (_b = audienceRes === null || audienceRes === void 0 ? void 0 : audienceRes.uid) !== null && _b !== void 0 ? _b : '';
+                            cli_utilities_1.log.debug(`Created audience: ${uid} -> ${audienceRes === null || audienceRes === void 0 ? void 0 : audienceRes.uid}`, this.config.context);
                         }
                         catch (error) {
-                            this.log(this.config, `Failed to create audience uid: ${uid}, name: ${name}`, 'error');
-                            this.log(this.config, error, 'error');
+                            (0, cli_utilities_1.handleAndLogError)(error, this.config.context, `Failed to create audience: ${name} (${uid})`);
                         }
                     }
                     utils_1.fsUtil.writeFile(this.audiencesUidMapperPath, this.audiencesUidMapper);
-                    this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Audiences' }), 'info');
+                    cli_utilities_1.log.debug(`Saved ${Object.keys(this.audiencesUidMapper).length} audience mappings to: ${this.audiencesUidMapperPath}`, this.config.context);
+                    cli_utilities_1.log.success('Audiences imported successfully', this.config.context);
                 }
                 catch (error) {
-                    this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Audiences' }), 'error');
-                    this.log(this.config, error, 'error');
+                    (0, cli_utilities_1.handleAndLogError)(error, this.config.context);
                 }
             }
+            else {
+                cli_utilities_1.log.warn(`Audiences file not found: ${audiencesPath}`, this.config.context);
+            }
         });
     }
 }

package/lib/import/events.d.ts

@@ -1,17 +1,16 @@
 import { PersonalizationAdapter } from '../utils';
-import { ImportConfig, LogType } from '../types';
+import { ImportConfig } from '../types';
 export default class Events extends PersonalizationAdapter<ImportConfig> {
     readonly config: ImportConfig;
-    private readonly log;
     private mapperDirPath;
     private eventMapperDirPath;
     private eventsUidMapperPath;
     private eventsUidMapper;
     private personalizeConfig;
     private eventsConfig;
-    constructor(config: ImportConfig, log?: LogType);
+    constructor(config: ImportConfig);
     /**
-     * The function asynchronously imports attributes from a JSON file and creates them in the system.
+     * The function asynchronously imports events from a JSON file and creates them in the system.
      */
     import(): Promise<void>;
 }

package/lib/import/events.js

@@ -14,7 +14,7 @@ const fs_1 = require("fs");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
 const utils_1 = require("../utils");
 class Events extends utils_1.PersonalizationAdapter {
-    constructor(config, log = console.log) {
+    constructor(config) {
         const conf = {
             config,
             baseURL: config.modules.personalize.baseURL[config.region.name],
@@ -22,47 +22,54 @@ class Events extends utils_1.PersonalizationAdapter {
         };
         super(Object.assign(config, conf));
         this.config = config;
-        this.log = log;
         this.personalizeConfig = this.config.modules.personalize;
         this.eventsConfig = this.personalizeConfig.events;
         this.mapperDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.personalizeConfig.dirName));
         this.eventMapperDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.mapperDirPath), (0, cli_utilities_1.sanitizePath)(this.eventsConfig.dirName));
         this.eventsUidMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.eventMapperDirPath), 'uid-mapping.json');
         this.eventsUidMapper = {};
+        this.config.context.module = 'events';
     }
     /**
-     * The function asynchronously imports attributes from a JSON file and creates them in the system.
+     * The function asynchronously imports events from a JSON file and creates them in the system.
      */
     import() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Events' }), 'info');
             yield this.init();
             yield utils_1.fsUtil.makeDirectory(this.eventMapperDirPath);
+            cli_utilities_1.log.debug(`Created mapper directory: ${this.eventMapperDirPath}`, this.config.context);
             const { dirName, fileName } = this.eventsConfig;
             const eventsPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.data), (0, cli_utilities_1.sanitizePath)(this.personalizeConfig.dirName), (0, cli_utilities_1.sanitizePath)(dirName), (0, cli_utilities_1.sanitizePath)(fileName));
+            cli_utilities_1.log.debug(`Checking for events file: ${eventsPath}`, this.config.context);
             if ((0, fs_1.existsSync)(eventsPath)) {
                 try {
                     const events = utils_1.fsUtil.readFile(eventsPath, true);
+                    cli_utilities_1.log.info(`Found ${events.length} events to import`, this.config.context);
                     for (const event of events) {
                         const { key, description, uid } = event;
+                        cli_utilities_1.log.debug(`Processing event: ${key} (${uid})`, this.config.context);
                         try {
+                            cli_utilities_1.log.debug(`Creating event: ${key}`, this.config.context);
                             const eventsResponse = yield this.createEvents({ key, description });
                             this.eventsUidMapper[uid] = (_a = eventsResponse === null || eventsResponse === void 0 ? void 0 : eventsResponse.uid) !== null && _a !== void 0 ? _a : '';
+                            cli_utilities_1.log.debug(`Created event: ${uid} -> ${eventsResponse === null || eventsResponse === void 0 ? void 0 : eventsResponse.uid}`, this.config.context);
                         }
                         catch (error) {
-                            this.log(this.config, `failed to create event uid: ${uid}`, 'error');
-                            this.log(this.config, error, 'error');
+                            (0, cli_utilities_1.handleAndLogError)(error, this.config.context, `Failed to create event: ${key} (${uid})`);
                         }
                     }
                     utils_1.fsUtil.writeFile(this.eventsUidMapperPath, this.eventsUidMapper);
-                    this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Events' }), 'info');
+                    cli_utilities_1.log.debug(`Saved ${Object.keys(this.eventsUidMapper).length} event mappings to: ${this.eventsUidMapperPath}`, this.config.context);
+                    cli_utilities_1.log.success('Events imported successfully', this.config.context);
                 }
                 catch (error) {
-                    this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Events' }), 'error');
-                    this.log(this.config, error, 'error');
+                    (0, cli_utilities_1.handleAndLogError)(error, this.config.context);
                 }
             }
+            else {
+                cli_utilities_1.log.warn(`Events file not found: ${eventsPath}`, this.config.context);
+            }
         });
     }
 }

package/lib/import/experiences.d.ts

@@ -1,8 +1,7 @@
 import { PersonalizationAdapter } from '../utils';
-import { ImportConfig, ExperienceStruct, LogType } from '../types';
+import { ImportConfig, ExperienceStruct } from '../types';
 export default class Experiences extends PersonalizationAdapter<ImportConfig> {
     readonly config: ImportConfig;
-    private readonly log;
     private createdCTs;
     private mapperDirPath;
     private cmsVariantPath;
@@ -30,7 +29,7 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
     private personalizeConfig;
     private audienceConfig;
     private experienceConfig;
-    constructor(config: ImportConfig, log?: LogType);
+    constructor(config: ImportConfig);
     /**
      * The function asynchronously imports experiences from a JSON file and creates them in the system.
      */

package/lib/import/experiences.js

@@ -30,7 +30,7 @@ const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
 const cli_utilities_1 = require("@contentstack/cli-utilities");
 const utils_1 = require("../utils");
 class Experiences extends utils_1.PersonalizationAdapter {
-    constructor(config, log = console.log) {
+    constructor(config) {
         var _a, _b, _c, _d;
         const conf = {
             config,
@@ -43,7 +43,6 @@ class Experiences extends utils_1.PersonalizationAdapter {
         };
         super(Object.assign(config, conf));
         this.config = config;
-        this.log = log;
         this.personalizeConfig = this.config.modules.personalize;
         this.experiencesDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.data), (0, cli_utilities_1.sanitizePath)(this.personalizeConfig.dirName), (0, cli_utilities_1.sanitizePath)(this.personalizeConfig.experiences.dirName));
         this.experiencesPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.experiencesDirPath), (0, cli_utilities_1.sanitizePath)(this.personalizeConfig.experiences.fileName));
@@ -72,6 +71,7 @@ class Experiences extends utils_1.PersonalizationAdapter {
         this.createdCTs = [];
         this.audiencesUid = utils_1.fsUtil.readFile(this.audiencesMapperPath, true) || {};
         this.eventsUid = utils_1.fsUtil.readFile(this.eventsMapperPath, true) || {};
+        this.config.context.module = 'experiences';
     }
     /**
      * The function asynchronously imports experiences from a JSON file and creates them in the system.
@@ -79,14 +79,17 @@ class Experiences extends utils_1.PersonalizationAdapter {
     import() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Experiences' }), 'info');
             yield this.init();
             yield utils_1.fsUtil.makeDirectory(this.expMapperDirPath);
+            cli_utilities_1.log.debug(`Created mapper directory: ${this.expMapperDirPath}`, this.config.context);
             if ((0, fs_1.existsSync)(this.experiencesPath)) {
+                cli_utilities_1.log.debug(`Loading experiences from: ${this.experiencesPath}`, this.config.context);
                 try {
                     const experiences = utils_1.fsUtil.readFile(this.experiencesPath, true);
+                    cli_utilities_1.log.info(`Found ${experiences.length} experiences to import`, this.config.context);
                     for (const experience of experiences) {
                         const { uid } = experience, restExperienceData = __rest(experience, ["uid"]);
+                        cli_utilities_1.log.debug(`Processing experience: ${uid}`, this.config.context);
                         //check whether reference audience exists or not that referenced in variations having __type equal to AudienceBasedVariation & targeting
                         let experienceReqObj = (0, utils_1.lookUpAudiences)(restExperienceData, this.audiencesUid);
                         //check whether events exists or not that referenced in metrics
@@ -94,40 +97,43 @@ class Experiences extends utils_1.PersonalizationAdapter {
                         const expRes = (yield this.createExperience(experienceReqObj));
                         //map old experience uid to new experience uid
                         this.experiencesUidMapper[uid] = (_a = expRes === null || expRes === void 0 ? void 0 : expRes.uid) !== null && _a !== void 0 ? _a : '';
+                        cli_utilities_1.log.debug(`Created experience: ${uid} -> ${expRes === null || expRes === void 0 ? void 0 : expRes.uid}`, this.config.context);
                         try {
                             // import versions of experience
                             yield this.importExperienceVersions(expRes, uid);
                         }
                         catch (error) {
-                            this.log(this.config, `Error while importing experience versions of ${expRes.uid}`, 'error');
-                            this.log(this.config, error, 'error');
+                            (0, cli_utilities_1.handleAndLogError)(error, this.config.context, `Failed to import experience versions for ${expRes.uid}`);
                         }
                     }
                     utils_1.fsUtil.writeFile(this.experiencesUidMapperPath, this.experiencesUidMapper);
-                    this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Experiences' }), 'info');
-                    this.log(this.config, this.messages.VALIDATE_VARIANT_AND_VARIANT_GRP, 'info');
+                    cli_utilities_1.log.success('Experiences created successfully', this.config.context);
+                    cli_utilities_1.log.info('Validating variant and variant group creation', this.config.context);
                     this.pendingVariantAndVariantGrpForExperience = (0, values_1.default)((0, cloneDeep_1.default)(this.experiencesUidMapper));
                     const jobRes = yield this.validateVariantGroupAndVariantsCreated();
                     utils_1.fsUtil.writeFile(this.cmsVariantPath, this.cmsVariants);
                     utils_1.fsUtil.writeFile(this.cmsVariantGroupPath, this.cmsVariantGroups);
                     if (jobRes) {
-                        this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Variant & Variant groups' }), 'info');
+                        cli_utilities_1.log.success('Variant and variant groups created successfully', this.config.context);
                     }
                     else {
+                        cli_utilities_1.log.error('Failed to create variants and variant groups', this.config.context);
                         this.personalizeConfig.importData = false;
                     }
                     if (this.personalizeConfig.importData) {
-                        this.log(this.config, this.messages.UPDATING_CT_IN_EXP, 'info');
+                        cli_utilities_1.log.info('Attaching content types to experiences', this.config.context);
                         yield this.attachCTsInExperience();
-                        this.log(this.config, this.messages.UPDATED_CT_IN_EXP, 'info');
+                        cli_utilities_1.log.success('Content types attached to experiences successfully', this.config.context);
                     }
                     yield this.createVariantIdMapper();
                 }
                 catch (error) {
-                    this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Experiences' }), 'error');
-                    this.log(this.config, error, 'error');
+                    (0, cli_utilities_1.handleAndLogError)(error, this.config.context);
                 }
             }
+            else {
+                cli_utilities_1.log.warn(`Experiences file not found: ${this.experiencesPath}`, this.config.context);
+            }
         });
     }
     /**
@@ -135,11 +141,14 @@ class Experiences extends utils_1.PersonalizationAdapter {
      */
     importExperienceVersions(experience, oldExperienceUid) {
         return __awaiter(this, void 0, void 0, function* () {
+            cli_utilities_1.log.debug(`Importing versions for experience: ${oldExperienceUid}`, this.config.context);
             const versionsPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.experiencesDirPath), 'versions', `${(0, cli_utilities_1.sanitizePath)(oldExperienceUid)}.json`);
             if (!(0, fs_1.existsSync)(versionsPath)) {
+                cli_utilities_1.log.debug(`No versions file found for experience: ${oldExperienceUid}`, this.config.context);
                 return;
             }
             const versions = utils_1.fsUtil.readFile(versionsPath, true);
+            cli_utilities_1.log.debug(`Found ${versions.length} versions for experience: ${oldExperienceUid}`, this.config.context);
             const versionMap = {
                 ACTIVE: undefined,
                 DRAFT: undefined,
@@ -151,6 +160,7 @@ class Experiences extends utils_1.PersonalizationAdapter {
                 versionReqObj = (0, utils_1.lookUpEvents)(version, this.eventsUid);
                 if (versionReqObj && versionReqObj.status) {
                     versionMap[versionReqObj.status] = versionReqObj;
+                    cli_utilities_1.log.debug(`Mapped version with status: ${versionReqObj.status}`, this.config.context);
                 }
             });
             // Prioritize updating or creating versions based on the order: ACTIVE -> DRAFT -> PAUSE
@@ -160,26 +170,32 @@ class Experiences extends utils_1.PersonalizationAdapter {
     // Helper method to handle version update or creation logic
     handleVersionUpdateOrCreate(experience, versionMap) {
         return __awaiter(this, void 0, void 0, function* () {
+            cli_utilities_1.log.debug(`Handling version update/create for experience: ${experience.uid}`, this.config.context);
             const { ACTIVE, DRAFT, PAUSE } = versionMap;
             let latestVersionUsed = false;
             if (ACTIVE) {
+                cli_utilities_1.log.debug(`Updating experience version to ACTIVE for: ${experience.uid}`, this.config.context);
                 yield this.updateExperienceVersion(experience.uid, experience.latestVersion, ACTIVE);
                 latestVersionUsed = true;
             }
             if (DRAFT) {
                 if (latestVersionUsed) {
+                    cli_utilities_1.log.debug(`Creating new DRAFT version for: ${experience.uid}`, this.config.context);
                     yield this.createExperienceVersion(experience.uid, DRAFT);
                 }
                 else {
+                    cli_utilities_1.log.debug(`Updating experience version to DRAFT for: ${experience.uid}`, this.config.context);
                     yield this.updateExperienceVersion(experience.uid, experience.latestVersion, DRAFT);
                     latestVersionUsed = true;
                 }
             }
             if (PAUSE) {
                 if (latestVersionUsed) {
+                    cli_utilities_1.log.debug(`Creating new PAUSE version for: ${experience.uid}`, this.config.context);
                     yield this.createExperienceVersion(experience.uid, PAUSE);
                 }
                 else {
+                    cli_utilities_1.log.debug(`Updating experience version to PAUSE for: ${experience.uid}`, this.config.context);
                     yield this.updateExperienceVersion(experience.uid, experience.latestVersion, PAUSE);
                 }
             }
@@ -195,88 +211,115 @@ class Experiences extends utils_1.PersonalizationAdapter {
     validateVariantGroupAndVariantsCreated() {
         return __awaiter(this, arguments, void 0, function* (retryCount = 0) {
             var _a;
+            cli_utilities_1.log.debug(`Validating variant groups and variants creation - attempt ${retryCount + 1}/${this.maxValidateRetry}`, this.config.context);
             try {
                 const promises = this.pendingVariantAndVariantGrpForExperience.map((expUid) => __awaiter(this, void 0, void 0, function* () {
                     var _a, _b, _c, _d, _e, _f, _g;
+                    cli_utilities_1.log.debug(`Checking experience: ${expUid}`, this.config.context);
                     const expRes = yield this.getExperience(expUid);
                     const variants = (_b = (_a = expRes === null || expRes === void 0 ? void 0 : expRes._cms) === null || _a === void 0 ? void 0 : _a.variants) !== null && _b !== void 0 ? _b : {};
                     if ((expRes === null || expRes === void 0 ? void 0 : expRes._cms) && ((_c = expRes === null || expRes === void 0 ? void 0 : expRes._cms) === null || _c === void 0 ? void 0 : _c.variantGroup) && Object.keys(variants).length > 0) {
+                        cli_utilities_1.log.debug(`Found variants and variant group for experience: ${expUid}`, this.config.context);
                         this.cmsVariants[expUid] = (_e = (_d = expRes._cms) === null || _d === void 0 ? void 0 : _d.variants) !== null && _e !== void 0 ? _e : {};
                         this.cmsVariantGroups[expUid] = (_g = (_f = expRes._cms) === null || _f === void 0 ? void 0 : _f.variantGroup) !== null && _g !== void 0 ? _g : {};
                         return expUid; // Return the expUid for filtering later
                     }
+                    else {
+                        cli_utilities_1.log.debug(`Variants/variant group not ready for experience: ${expUid}`, this.config.context);
+                    }
                 }));
                 yield Promise.all(promises);
                 retryCount++;
                 if ((_a = this.pendingVariantAndVariantGrpForExperience) === null || _a === void 0 ? void 0 : _a.length) {
                     if (retryCount !== this.maxValidateRetry) {
+                        cli_utilities_1.log.debug(`Waiting ${this.expCheckIntervalDuration}ms before retry`, this.config.context);
                         yield this.delay(this.expCheckIntervalDuration);
                         // Filter out the processed elements
                         this.pendingVariantAndVariantGrpForExperience = this.pendingVariantAndVariantGrpForExperience.filter((uid) => !this.cmsVariants[uid]);
                         return this.validateVariantGroupAndVariantsCreated(retryCount);
                     }
                     else {
-                        this.log(this.config, this.messages.PERSONALIZE_JOB_FAILURE, 'error');
+                        cli_utilities_1.log.error('Personalize job failed to create variants and variant groups', this.config.context);
+                        cli_utilities_1.log.error(`Failed experiences: ${this.pendingVariantAndVariantGrpForExperience.join(', ')}`, this.config.context);
                         utils_1.fsUtil.writeFile(this.failedCmsExpPath, this.pendingVariantAndVariantGrpForExperience);
                         return false;
                     }
                 }
                 else {
+                    cli_utilities_1.log.debug('All variant groups and variants created successfully', this.config.context);
                     return true;
                 }
             }
             catch (error) {
-                this.log(this.config, `Error while validating variant group and variants creation:`, 'error');
+                (0, cli_utilities_1.handleAndLogError)(error, this.config.context);
                 throw error;
             }
         });
     }
     attachCTsInExperience() {
         return __awaiter(this, void 0, void 0, function* () {
+            cli_utilities_1.log.debug('Attaching content types to experiences', this.config.context);
             try {
                 // Read the created content types from the file
                 this.createdCTs = utils_1.fsUtil.readFile(this.cTsSuccessPath, true);
                 if (!this.createdCTs) {
-                    this.log(this.config, 'No Content types created, skipping following process', 'error');
+                    cli_utilities_1.log.debug('No Content types created, skipping following process', this.config.context);
                     return;
                 }
+                cli_utilities_1.log.debug(`Found ${this.createdCTs.length} created content types`, this.config.context);
                 const experienceCTsMap = utils_1.fsUtil.readFile(this.experienceCTsPath, true);
                 return yield Promise.allSettled(Object.entries(this.experiencesUidMapper).map((_a) => __awaiter(this, [_a], void 0, function* ([oldExpUid, newExpUid]) {
                     var _b;
                     if ((_b = experienceCTsMap[oldExpUid]) === null || _b === void 0 ? void 0 : _b.length) {
+                        cli_utilities_1.log.debug(`Processing content types for experience: ${oldExpUid} -> ${newExpUid}`, this.config.context);
                         // Filter content types that were created
                         const updatedContentTypes = experienceCTsMap[oldExpUid].filter((ct) => this.createdCTs.includes(ct === null || ct === void 0 ? void 0 : ct.uid) && ct.status === 'linked');
                         if (updatedContentTypes === null || updatedContentTypes === void 0 ? void 0 : updatedContentTypes.length) {
+                            cli_utilities_1.log.debug(`Attaching ${updatedContentTypes.length} content types to experience: ${newExpUid}`, this.config.context);
                             const { variant_groups: [variantGroup] = [] } = (yield this.getVariantGroup({ experienceUid: newExpUid })) || {};
                             variantGroup.content_types = updatedContentTypes;
                             // Update content types detail in the new experience asynchronously
                             return yield this.updateVariantGroup(variantGroup);
                         }
+                        else {
+                            cli_utilities_1.log.debug(`No valid content types found for experience: ${newExpUid}`, this.config.context);
+                        }
+                    }
+                    else {
+                        cli_utilities_1.log.debug(`No content types mapped for experience: ${oldExpUid}`, this.config.context);
                     }
                 })));
             }
             catch (error) {
-                this.log(this.config, `Error while attaching content type with experience`, 'error');
-                this.log(this.config, error, 'error');
+                (0, cli_utilities_1.handleAndLogError)(error, this.config.context, 'Failed to attach content type with experience');
             }
         });
     }
     createVariantIdMapper() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
+            cli_utilities_1.log.debug('Creating variant ID mapper', this.config.context);
             try {
                 const experienceVariantIds = utils_1.fsUtil.readFile(this.experienceVariantsIdsPath, true) || [];
+                cli_utilities_1.log.debug(`Found ${experienceVariantIds.length} experience variant IDs to process`, this.config.context);
                 const variantUIDMapper = {};
                 for (let experienceVariantId of experienceVariantIds) {
                     const [experienceId, variantShortId, oldVariantId] = experienceVariantId.split('-');
                     const latestVariantId = (_a = this.cmsVariants[this.experiencesUidMapper[experienceId]]) === null || _a === void 0 ? void 0 : _a[variantShortId];
                     if (latestVariantId) {
                         variantUIDMapper[oldVariantId] = latestVariantId;
+                        cli_utilities_1.log.debug(`Mapped variant ID: ${oldVariantId} -> ${latestVariantId}`, this.config.context);
+                    }
+                    else {
+                        cli_utilities_1.log.warn(`Could not find variant ID mapping for: ${experienceVariantId}`, this.config.context);
                     }
                 }
+                cli_utilities_1.log.debug(`Created ${Object.keys(variantUIDMapper).length} variant ID mappings`, this.config.context);
                 utils_1.fsUtil.writeFile(this.variantUidMapperFilePath, variantUIDMapper);
+                cli_utilities_1.log.debug(`Variant ID mapper saved to: ${this.variantUidMapperFilePath}`, this.config.context);
             }
             catch (error) {
+                (0, cli_utilities_1.handleAndLogError)(error, this.config.context, 'Failed to create variant ID mapper');
                 throw error;
             }
         });

package/lib/import/project.d.ts

@@ -1,10 +1,9 @@
 import { PersonalizationAdapter } from '../utils';
-import { ImportConfig, LogType } from '../types';
+import { ImportConfig } from '../types';
 export default class Project extends PersonalizationAdapter<ImportConfig> {
     readonly config: ImportConfig;
-    private readonly log;
     private projectMapperFolderPath;
-    constructor(config: ImportConfig, log?: LogType);
+    constructor(config: ImportConfig);
     /**
      * The function asynchronously imports projects data from a file and creates projects based on the
      * data.

package/lib/import/project.js

@@ -14,7 +14,7 @@ const fs_1 = require("fs");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
 const utils_1 = require("../utils");
 class Project extends utils_1.PersonalizationAdapter {
-    constructor(config, log = console.log) {
+    constructor(config) {
         const conf = {
             config,
             baseURL: config.modules.personalize.baseURL[config.region.name],
@@ -22,8 +22,8 @@ class Project extends utils_1.PersonalizationAdapter {
         };
         super(Object.assign(config, conf));
         this.config = config;
-        this.log = log;
         this.projectMapperFolderPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.config.modules.personalize.dirName), 'projects');
+        this.config.context.module = 'project';
     }
     /**
      * The function asynchronously imports projects data from a file and creates projects based on the
@@ -34,16 +34,20 @@ class Project extends utils_1.PersonalizationAdapter {
             const personalize = this.config.modules.personalize;
             const { dirName, fileName } = personalize.projects;
             const projectPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.data), (0, cli_utilities_1.sanitizePath)(personalize.dirName), (0, cli_utilities_1.sanitizePath)(dirName), (0, cli_utilities_1.sanitizePath)(fileName));
+            cli_utilities_1.log.debug(`Checking for project file: ${projectPath}`, this.config.context);
             if ((0, fs_1.existsSync)(projectPath)) {
                 const projects = JSON.parse((0, fs_1.readFileSync)(projectPath, 'utf8'));
+                cli_utilities_1.log.debug(`Loaded ${(projects === null || projects === void 0 ? void 0 : projects.length) || 0} projects from file`, this.config.context);
                 if (!projects || projects.length < 1) {
                     this.config.modules.personalize.importData = false; // Stop personalize import if stack not connected to any project
-                    this.log(this.config, 'No project found!', 'info');
+                    cli_utilities_1.log.warn('No projects found in file', this.config.context);
                     return;
                 }
                 yield this.init();
                 for (const project of projects) {
+                    cli_utilities_1.log.debug(`Processing project: ${project.name}`, this.config.context);
                     const createProject = (newName) => __awaiter(this, void 0, void 0, function* () {
+                        cli_utilities_1.log.debug(`Creating project with name: ${newName || project.name}`, this.config.context);
                         return yield this.createProject({
                             name: newName || project.name,
                             description: project.description,
@@ -51,10 +55,10 @@ class Project extends utils_1.PersonalizationAdapter {
                         }).catch((error) => __awaiter(this, void 0, void 0, function* () {
                             if (error.includes('personalization.PROJECTS.DUPLICATE_NAME') ||
                                 error.includes('personalize.PROJECTS.DUPLICATE_NAME')) {
+                                cli_utilities_1.log.warn(`Project name already exists, generating new name`, this.config.context);
                                 const projectName = yield (0, utils_1.askProjectName)('Copy Of ' + (newName || project.name));
                                 return yield createProject(projectName);
                             }
-                            this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Projects' }), 'error');
                             throw error;
                         }));
                     });
@@ -63,12 +67,13 @@ class Project extends utils_1.PersonalizationAdapter {
                     this.config.modules.personalize.importData = true;
                     yield utils_1.fsUtil.makeDirectory(this.projectMapperFolderPath);
                     utils_1.fsUtil.writeFile((0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.projectMapperFolderPath), 'projects.json'), projectRes);
-                    this.log(this.config, `Project Created Successfully: ${projectRes.uid}`, 'info');
+                    cli_utilities_1.log.success(`Project created successfully: ${projectRes.uid}`, this.config.context);
+                    cli_utilities_1.log.debug(`Project data saved to: ${this.projectMapperFolderPath}/projects.json`, this.config.context);
                 }
             }
             else {
                 this.config.modules.personalize.importData = false; // Stop personalize import if stack not connected to any project
-                this.log(this.config, 'No project found!', 'info');
+                cli_utilities_1.log.warn(`Project file not found: ${projectPath}`, this.config.context);
             }
         });
     }