@contentstack/cli-variants 0.0.1-alpha

package/lib/import/attribute.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const utils_1 = require("../utils");
+class Attribute extends utils_1.PersonalizationAdapter {
+    constructor(config, log = console.log) {
+        const conf = {
+            config,
+            baseURL: config.modules.personalization.baseURL[config.region.name],
+            headers: { 'X-Project-Uid': config.modules.personalization.project_id, authtoken: config.auth_token },
+        };
+        super(Object.assign(config, conf));
+        this.config = config;
+        this.log = log;
+        this.personalizationConfig = this.config.modules.personalization;
+        this.attributeConfig = this.personalizationConfig.attributes;
+        this.mapperDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.dirName));
+        this.attrMapperDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.mapperDirPath), (0, cli_utilities_1.sanitizePath)(this.attributeConfig.dirName));
+        this.attributesUidMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.attrMapperDirPath), 'uid-mapping.json');
+        this.attributesUidMapper = {};
+    }
+    /**
+     * The function asynchronously imports attributes 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: 'Attributes' }), 'info');
+            yield utils_1.fsUtil.makeDirectory(this.attrMapperDirPath);
+            const { dirName, fileName } = this.attributeConfig;
+            const attributesPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.data), (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.dirName), (0, cli_utilities_1.sanitizePath)(dirName), (0, cli_utilities_1.sanitizePath)(fileName));
+            if ((0, fs_1.existsSync)(attributesPath)) {
+                try {
+                    const attributes = utils_1.fsUtil.readFile(attributesPath, true);
+                    for (const attribute of attributes) {
+                        const { key, name, description, uid } = attribute;
+                        const attributeRes = yield this.createAttribute({ key, name, description });
+                        //map old attribute uid to new attribute uid
+                        //mapper file is used to check whether attribute created or not before creating audience
+                        this.attributesUidMapper[uid] = (_a = attributeRes === null || attributeRes === void 0 ? void 0 : attributeRes.uid) !== null && _a !== void 0 ? _a : '';
+                    }
+                    utils_1.fsUtil.writeFile(this.attributesUidMapperPath, this.attributesUidMapper);
+                    this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Attributes' }), 'info');
+                }
+                catch (error) {
+                    this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Attributes' }), 'error');
+                    this.log(this.config, error, 'error');
+                }
+            }
+        });
+    }
+}
+exports.default = Attribute;

package/lib/import/audiences.d.ts

@@ -0,0 +1,19 @@
+import { ImportConfig, LogType } from '../types';
+import { PersonalizationAdapter } from '../utils';
+export default class Audiences extends PersonalizationAdapter<ImportConfig> {
+    readonly config: ImportConfig;
+    private readonly log;
+    private mapperDirPath;
+    private audienceMapperDirPath;
+    private attributesMapperPath;
+    private audiencesUidMapperPath;
+    private audiencesUidMapper;
+    private personalizationConfig;
+    private audienceConfig;
+    attributeConfig: ImportConfig['modules']['personalization']['attributes'];
+    constructor(config: ImportConfig, log?: LogType);
+    /**
+     * The function asynchronously imports audiences from a JSON file and creates them in the system.
+     */
+    import(): Promise<void>;
+}

package/lib/import/audiences.js

@@ -0,0 +1,71 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+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) {
+        const conf = {
+            config,
+            baseURL: config.modules.personalization.baseURL[config.region.name],
+            headers: { 'X-Project-Uid': config.modules.personalization.project_id, authtoken: config.auth_token },
+        };
+        super(Object.assign(config, conf));
+        this.config = config;
+        this.log = log;
+        this.personalizationConfig = this.config.modules.personalization;
+        this.audienceConfig = this.personalizationConfig.audiences;
+        this.attributeConfig = this.personalizationConfig.attributes;
+        this.mapperDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.dirName));
+        this.audienceMapperDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.mapperDirPath), (0, cli_utilities_1.sanitizePath)(this.audienceConfig.dirName));
+        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 = {};
+    }
+    /**
+     * The function asynchronously imports audiences from a JSON file and creates them in the system.
+     */
+    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 utils_1.fsUtil.makeDirectory(this.audienceMapperDirPath);
+            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.personalizationConfig.dirName), (0, cli_utilities_1.sanitizePath)(dirName), (0, cli_utilities_1.sanitizePath)(fileName));
+            if ((0, fs_1.existsSync)(audiencesPath)) {
+                try {
+                    const audiences = utils_1.fsUtil.readFile(audiencesPath, true);
+                    const attributesUid = utils_1.fsUtil.readFile(this.attributesMapperPath, true) || {};
+                    for (const audience of audiences) {
+                        let { name, definition, description, uid } = audience;
+                        //check whether reference attributes exists or not
+                        if ((_a = definition.rules) === null || _a === void 0 ? void 0 : _a.length) {
+                            definition.rules = (0, utils_1.lookUpAttributes)(definition.rules, attributesUid);
+                        }
+                        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 : '';
+                    }
+                    utils_1.fsUtil.writeFile(this.audiencesUidMapperPath, this.audiencesUidMapper);
+                    this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Audiences' }), 'info');
+                }
+                catch (error) {
+                    this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Audiences' }), 'error');
+                    this.log(this.config, error, 'error');
+                }
+            }
+        });
+    }
+}
+exports.default = Audiences;

package/lib/import/events.d.ts

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

package/lib/import/events.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+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) {
+        const conf = {
+            config,
+            baseURL: config.modules.personalization.baseURL[config.region.name],
+            headers: { 'X-Project-Uid': config.modules.personalization.project_id, authtoken: config.auth_token },
+        };
+        super(Object.assign(config, conf));
+        this.config = config;
+        this.log = log;
+        this.personalizationConfig = this.config.modules.personalization;
+        this.eventsConfig = this.personalizationConfig.events;
+        this.mapperDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.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 = {};
+    }
+    /**
+     * The function asynchronously imports attributes 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 utils_1.fsUtil.makeDirectory(this.eventMapperDirPath);
+            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.personalizationConfig.dirName), (0, cli_utilities_1.sanitizePath)(dirName), (0, cli_utilities_1.sanitizePath)(fileName));
+            if ((0, fs_1.existsSync)(eventsPath)) {
+                try {
+                    const events = utils_1.fsUtil.readFile(eventsPath, true);
+                    for (const event of events) {
+                        const { key, description, uid } = event;
+                        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 : '';
+                    }
+                    utils_1.fsUtil.writeFile(this.eventsUidMapperPath, this.eventsUidMapper);
+                    this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Events' }), 'info');
+                }
+                catch (error) {
+                    this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Events' }), 'error');
+                    this.log(this.config, error, 'error');
+                }
+            }
+        });
+    }
+}
+exports.default = Events;

package/lib/import/experiences.d.ts

@@ -0,0 +1,46 @@
+import { PersonalizationAdapter } from '../utils';
+import { ImportConfig, LogType } from '../types';
+export default class Experiences extends PersonalizationAdapter<ImportConfig> {
+    readonly config: ImportConfig;
+    private readonly log;
+    private createdCTs;
+    private mapperDirPath;
+    private cmsVariantPath;
+    private cTsSuccessPath;
+    private failedCmsExpPath;
+    private expMapperDirPath;
+    private eventsMapperPath;
+    private experiencesPath;
+    private experiencesDirPath;
+    private audiencesMapperPath;
+    private cmsVariantGroupPath;
+    private experienceVariantsIdsPath;
+    private variantUidMapperFilePath;
+    private expThresholdTimer;
+    private maxValidateRetry;
+    private experiencesUidMapperPath;
+    private experienceCTsPath;
+    private expCheckIntervalDuration;
+    private cmsVariants;
+    private cmsVariantGroups;
+    private experiencesUidMapper;
+    private pendingVariantAndVariantGrpForExperience;
+    private personalizationConfig;
+    private audienceConfig;
+    private experienceConfig;
+    constructor(config: ImportConfig, log?: LogType);
+    /**
+     * The function asynchronously imports experiences from a JSON file and creates them in the system.
+     */
+    import(): Promise<void>;
+    /**
+     * function to validate if all variant groups and variants have been created using personalization background job
+     * store the variant groups data in mapper/personalization/experiences/cms-variant-groups.json and the variants data
+     * in mapper/personalization/experiences/cms-variants.json. If not, invoke validateVariantGroupAndVariantsCreated after some delay.
+     * @param retryCount Counter to track the number of times the function has been called
+     * @returns
+     */
+    validateVariantGroupAndVariantsCreated(retryCount?: number): Promise<any>;
+    attachCTsInExperience(): Promise<PromiseSettledResult<void | import("../types").VariantGroup>[] | undefined>;
+    createVariantIdMapper(): Promise<void>;
+}

package/lib/import/experiences.js

@@ -0,0 +1,214 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+const values_1 = __importDefault(require("lodash/values"));
+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) {
+        var _a, _b, _c, _d;
+        const conf = {
+            config,
+            baseURL: config.modules.personalization.baseURL[config.region.name],
+            headers: { 'X-Project-Uid': config.modules.personalization.project_id, authtoken: config.auth_token },
+            cmaConfig: {
+                baseURL: config.region.cma + `/v3`,
+                headers: { authtoken: config.auth_token, api_key: config.apiKey },
+            },
+        };
+        super(Object.assign(config, conf));
+        this.config = config;
+        this.log = log;
+        this.personalizationConfig = this.config.modules.personalization;
+        this.experiencesDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.data), (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.dirName), (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.experiences.dirName));
+        this.experiencesPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.experiencesDirPath), (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.experiences.fileName));
+        this.experienceConfig = this.personalizationConfig.experiences;
+        this.audienceConfig = this.personalizationConfig.audiences;
+        this.mapperDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.dirName));
+        this.expMapperDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.mapperDirPath), (0, cli_utilities_1.sanitizePath)(this.experienceConfig.dirName));
+        this.experiencesUidMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.expMapperDirPath), 'uid-mapping.json');
+        this.cmsVariantGroupPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.expMapperDirPath), 'cms-variant-groups.json');
+        this.cmsVariantPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.expMapperDirPath), 'cms-variants.json');
+        this.audiencesMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.mapperDirPath), (0, cli_utilities_1.sanitizePath)(this.audienceConfig.dirName), 'uid-mapping.json');
+        this.eventsMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.mapperDirPath), 'events', 'uid-mapping.json');
+        this.failedCmsExpPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.expMapperDirPath), 'failed-cms-experience.json');
+        this.failedCmsExpPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.expMapperDirPath), 'failed-cms-experience.json');
+        this.experienceCTsPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.experiencesDirPath), 'experiences-content-types.json');
+        this.experienceVariantsIdsPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.data), (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.dirName), (0, cli_utilities_1.sanitizePath)(this.experienceConfig.dirName), 'experiences-variants-ids.json');
+        this.variantUidMapperFilePath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.expMapperDirPath), 'variants-uid-mapping.json');
+        this.experiencesUidMapper = {};
+        this.cmsVariantGroups = {};
+        this.cmsVariants = {};
+        this.expThresholdTimer = (_b = (_a = this.experienceConfig) === null || _a === void 0 ? void 0 : _a.thresholdTimer) !== null && _b !== void 0 ? _b : 30000;
+        this.expCheckIntervalDuration = (_d = (_c = this.experienceConfig) === null || _c === void 0 ? void 0 : _c.checkIntervalDuration) !== null && _d !== void 0 ? _d : 5000;
+        this.maxValidateRetry = Math.round(this.expThresholdTimer / this.expCheckIntervalDuration);
+        this.pendingVariantAndVariantGrpForExperience = [];
+        this.cTsSuccessPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'content_types', 'success.json');
+        this.createdCTs = [];
+    }
+    /**
+     * The function asynchronously imports experiences 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: 'Experiences' }), 'info');
+            yield utils_1.fsUtil.makeDirectory(this.expMapperDirPath);
+            if ((0, fs_1.existsSync)(this.experiencesPath)) {
+                try {
+                    const experiences = utils_1.fsUtil.readFile(this.experiencesPath, true);
+                    const audiencesUid = utils_1.fsUtil.readFile(this.audiencesMapperPath, true) || {};
+                    const eventsUid = utils_1.fsUtil.readFile(this.eventsMapperPath, true) || {};
+                    for (const experience of experiences) {
+                        const { uid } = experience, restExperienceData = __rest(experience, ["uid"]);
+                        //check whether reference audience exists or not that referenced in variations having __type equal to AudienceBasedVariation & targeting
+                        let experienceReqObj = (0, utils_1.lookUpAudiences)(restExperienceData, audiencesUid);
+                        //check whether events exists or not that referenced in metrics
+                        experienceReqObj = (0, utils_1.lookUpEvents)(experienceReqObj, eventsUid);
+                        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 : '';
+                    }
+                    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');
+                    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');
+                    if (this.personalizationConfig.importData) {
+                        this.log(this.config, this.messages.UPDATING_CT_IN_EXP, 'info');
+                        yield this.attachCTsInExperience();
+                    }
+                    yield this.createVariantIdMapper();
+                }
+                catch (error) {
+                    this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Experiences' }), 'error');
+                    this.log(this.config, error, 'error');
+                }
+            }
+        });
+    }
+    /**
+     * function to validate if all variant groups and variants have been created using personalization background job
+     * store the variant groups data in mapper/personalization/experiences/cms-variant-groups.json and the variants data
+     * in mapper/personalization/experiences/cms-variants.json. If not, invoke validateVariantGroupAndVariantsCreated after some delay.
+     * @param retryCount Counter to track the number of times the function has been called
+     * @returns
+     */
+    validateVariantGroupAndVariantsCreated() {
+        return __awaiter(this, arguments, void 0, function* (retryCount = 0) {
+            var _a;
+            try {
+                const promises = this.pendingVariantAndVariantGrpForExperience.map((expUid) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b, _c, _d;
+                    const expRes = yield this.getExperience(expUid);
+                    if (expRes === null || expRes === void 0 ? void 0 : expRes._cms) {
+                        this.cmsVariants[expUid] = (_b = (_a = expRes._cms) === null || _a === void 0 ? void 0 : _a.variants) !== null && _b !== void 0 ? _b : {};
+                        this.cmsVariantGroups[expUid] = (_d = (_c = expRes._cms) === null || _c === void 0 ? void 0 : _c.variantGroup) !== null && _d !== void 0 ? _d : {};
+                        return expUid; // Return the expUid for filtering later
+                    }
+                }));
+                yield Promise.all(promises);
+                retryCount++;
+                if ((_a = this.pendingVariantAndVariantGrpForExperience) === null || _a === void 0 ? void 0 : _a.length) {
+                    if (retryCount !== this.maxValidateRetry) {
+                        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.PERSONALIZATION_JOB_FAILURE, 'error');
+                        utils_1.fsUtil.writeFile(this.failedCmsExpPath, this.pendingVariantAndVariantGrpForExperience);
+                        return false;
+                    }
+                }
+                else {
+                    return true;
+                }
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    attachCTsInExperience() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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');
+                    return;
+                }
+                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) {
+                        // Filter content types that were created
+                        const updatedContentTypes = experienceCTsMap[oldExpUid].filter((ct) => this.createdCTs.includes(ct === null || ct === void 0 ? void 0 : ct.uid));
+                        if (updatedContentTypes === null || updatedContentTypes === void 0 ? void 0 : updatedContentTypes.length) {
+                            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);
+                        }
+                    }
+                })));
+            }
+            catch (error) {
+                this.log(this.config, `Error while attaching content type with experience`, 'error');
+                this.log(this.config, error, 'error');
+            }
+        });
+    }
+    createVariantIdMapper() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const experienceVariantIds = utils_1.fsUtil.readFile(this.experienceVariantsIdsPath, true) || [];
+                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;
+                    }
+                }
+                utils_1.fsUtil.writeFile(this.variantUidMapperFilePath, variantUIDMapper);
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+}
+exports.default = Experiences;

package/lib/import/index.d.ts

@@ -0,0 +1,14 @@
+import Events from './events';
+import Project from './project';
+import Attribute from './attribute';
+import Audiences from './audiences';
+import Experiences from './experiences';
+import VariantEntries from './variant-entries';
+export declare const Import: {
+    Events: typeof Events;
+    Project: typeof Project;
+    Attribute: typeof Attribute;
+    Audiences: typeof Audiences;
+    Experiences: typeof Experiences;
+    VariantEntries: typeof VariantEntries;
+};

package/lib/import/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Import = void 0;
+const events_1 = __importDefault(require("./events"));
+const project_1 = __importDefault(require("./project"));
+const attribute_1 = __importDefault(require("./attribute"));
+const audiences_1 = __importDefault(require("./audiences"));
+const experiences_1 = __importDefault(require("./experiences"));
+const variant_entries_1 = __importDefault(require("./variant-entries"));
+// NOTE Acting as namespace to avoid the same class name conflicts in other modules
+exports.Import = {
+    Events: events_1.default,
+    Project: project_1.default,
+    Attribute: attribute_1.default,
+    Audiences: audiences_1.default,
+    Experiences: experiences_1.default,
+    VariantEntries: variant_entries_1.default,
+};

package/lib/import/project.d.ts

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

package/lib/import/project.js

@@ -0,0 +1,74 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+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) {
+        const conf = {
+            config,
+            baseURL: config.modules.personalization.baseURL[config.region.name],
+            headers: { organization_uid: config.org_uid, authtoken: config.auth_token },
+        };
+        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.personalization.dirName), 'projects');
+    }
+    /**
+     * The function asynchronously imports projects data from a file and creates projects based on the
+     * data.
+     */
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const personalization = this.config.modules.personalization;
+            const { dirName, fileName } = personalization.projects;
+            const projectPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.data), (0, cli_utilities_1.sanitizePath)(personalization.dirName), (0, cli_utilities_1.sanitizePath)(dirName), (0, cli_utilities_1.sanitizePath)(fileName));
+            if ((0, fs_1.existsSync)(projectPath)) {
+                const projects = JSON.parse((0, fs_1.readFileSync)(projectPath, 'utf8'));
+                if (!projects || projects.length < 1) {
+                    this.config.modules.personalization.importData = false; // Stop personalization import if stack not connected to any project
+                    this.log(this.config, 'No project found!', 'info');
+                    return;
+                }
+                for (const project of projects) {
+                    const createProject = (newName) => __awaiter(this, void 0, void 0, function* () {
+                        return yield this.createProject({
+                            name: newName || project.name,
+                            description: project.description,
+                            connectedStackApiKey: this.config.apiKey,
+                        }).catch((error) => __awaiter(this, void 0, void 0, function* () {
+                            if (error === 'personalization.PROJECTS.DUPLICATE_NAME') {
+                                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;
+                        }));
+                    });
+                    const projectRes = yield createProject(this.config.personalizeProjectName);
+                    this.config.modules.personalization.project_id = projectRes.uid;
+                    this.config.modules.personalization.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');
+                }
+            }
+            else {
+                this.config.modules.personalization.importData = false; // Stop personalization import if stack not connected to any project
+                this.log(this.config, 'No project found!', 'info');
+            }
+        });
+    }
+}
+exports.default = Project;