@contentstack/cli-variants 0.0.1-alpha → 1.1.0

package/src/export/projects.ts

@@ -1,24 +1,24 @@
 import * as path from 'path';
 import { sanitizePath } from '@contentstack/cli-utilities';
-import { ExportConfig, PersonalizationConfig } from '../types';
+import { ExportConfig, PersonalizeConfig } from '../types';
 import { PersonalizationAdapter, log, fsUtil, formatError } from '../utils';
 
 export default class ExportProjects extends PersonalizationAdapter<ExportConfig> {
   private projectFolderPath: string;
   public exportConfig: ExportConfig;
-  public personalizationConfig: PersonalizationConfig;
+  public personalizeConfig: PersonalizeConfig;
   constructor(exportConfig: ExportConfig) {
     super({
       config: exportConfig,
-      baseURL: exportConfig.modules.personalization.baseURL[exportConfig.region.name],
-      headers: { authtoken: exportConfig.auth_token, organization_uid: exportConfig.org_uid },
+      baseURL: exportConfig.modules.personalize.baseURL[exportConfig.region.name],
+      headers: { organization_uid: exportConfig.org_uid },
     });
     this.exportConfig = exportConfig;
-    this.personalizationConfig = exportConfig.modules.personalization;
+    this.personalizeConfig = exportConfig.modules.personalize;
     this.projectFolderPath = path.resolve(
       sanitizePath(exportConfig.data),
       sanitizePath(exportConfig.branchName || ''),
-      sanitizePath(this.personalizationConfig.dirName),
+      sanitizePath(this.personalizeConfig.dirName),
       'projects',
     );
   }
@@ -26,10 +26,11 @@ export default class ExportProjects extends PersonalizationAdapter<ExportConfig>
   async start() {
     try {
       log(this.exportConfig, 'Starting projects export', 'info');
+      await this.init();
       await fsUtil.makeDirectory(this.projectFolderPath);
       const project = await this.projects({ connectedStackApiKey: this.exportConfig.apiKey });
       if (!project || project?.length < 1) {
-        log(this.exportConfig, 'No Personalization Project connected with the given stack', 'info');
+        log(this.exportConfig, 'No Personalize Project connected with the given stack', 'info');
         this.exportConfig.personalizationEnabled = false;
         return;
       }
@@ -38,7 +39,9 @@ export default class ExportProjects extends PersonalizationAdapter<ExportConfig>
       fsUtil.writeFile(path.resolve(sanitizePath(this.projectFolderPath), 'projects.json'), project);
       log(this.exportConfig, 'Project exported successfully!', 'success');
     } catch (error) {
-      log(this.exportConfig, `Failed to export projects!`, 'error');
+      if (error !== 'Forbidden') {
+        log(this.exportConfig, `Failed to export projects!`, 'error');
+      }
       throw error;
     }
   }

package/src/export/variant-entries.ts

@@ -19,7 +19,6 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
       headers: {
         api_key: config.apiKey,
         branch: config.branchName,
-        authtoken: config.auth_token,
         organization_uid: config.org_uid,
         'X-Project-Uid': config.project_id,
       },
@@ -36,7 +35,7 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
   async exportVariantEntry(options: { locale: string; contentTypeUid: string; entries: Record<string, any>[] }) {
     const variantEntry = this.config.modules.variantEntry;
     const { entries, locale, contentTypeUid: content_type_uid } = options;
-
+    await this.variantInstance.init();
     for (let index = 0; index < entries.length; index++) {
       const entry = entries[index];
       const variantEntryBasePath = join(sanitizePath(this.entriesDirPath), sanitizePath(content_type_uid), sanitizePath(locale), sanitizePath(variantEntry.dirName), sanitizePath(entry.uid));

package/src/import/attribute.ts

@@ -9,19 +9,23 @@ export default class Attribute extends PersonalizationAdapter<ImportConfig> {
   private attrMapperDirPath: string;
   private attributesUidMapperPath: string;
   private attributesUidMapper: Record<string, unknown>;
-  private personalizationConfig: ImportConfig['modules']['personalization'];
-  private attributeConfig: ImportConfig['modules']['personalization']['attributes'];
+  private personalizeConfig: ImportConfig['modules']['personalize'];
+  private attributeConfig: ImportConfig['modules']['personalize']['attributes'];
 
   constructor(public readonly config: ImportConfig, private readonly log: LogType = console.log) {
     const conf: APIConfig = {
       config,
-      baseURL: config.modules.personalization.baseURL[config.region.name],
-      headers: { 'X-Project-Uid': config.modules.personalization.project_id, authtoken: config.auth_token },
+      baseURL: config.modules.personalize.baseURL[config.region.name],
+      headers: { 'X-Project-Uid': config.modules.personalize.project_id },
     };
     super(Object.assign(config, conf));
-    this.personalizationConfig = this.config.modules.personalization;
-    this.attributeConfig = this.personalizationConfig.attributes;
-    this.mapperDirPath = resolve(sanitizePath(this.config.backupDir), 'mapper', sanitizePath(this.personalizationConfig.dirName));
+    this.personalizeConfig = this.config.modules.personalize;
+    this.attributeConfig = this.personalizeConfig.attributes;
+    this.mapperDirPath = resolve(
+      sanitizePath(this.config.backupDir),
+      'mapper',
+      sanitizePath(this.personalizeConfig.dirName),
+    );
     this.attrMapperDirPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.attributeConfig.dirName));
     this.attributesUidMapperPath = resolve(sanitizePath(this.attrMapperDirPath), 'uid-mapping.json');
     this.attributesUidMapper = {};
@@ -32,10 +36,15 @@ export default class Attribute extends PersonalizationAdapter<ImportConfig> {
    */
   async import() {
     this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Attributes' }), 'info');
-
+    await this.init();
     await fsUtil.makeDirectory(this.attrMapperDirPath);
     const { dirName, fileName } = this.attributeConfig;
-    const attributesPath = resolve(sanitizePath(this.config.data), sanitizePath(this.personalizationConfig.dirName), sanitizePath(dirName), sanitizePath(fileName));
+    const attributesPath = resolve(
+      sanitizePath(this.config.data),
+      sanitizePath(this.personalizeConfig.dirName),
+      sanitizePath(dirName),
+      sanitizePath(fileName),
+    );
 
     if (existsSync(attributesPath)) {
       try {
@@ -43,10 +52,19 @@ export default class Attribute extends PersonalizationAdapter<ImportConfig> {
 
         for (const attribute of attributes) {
           const { key, name, description, uid } = attribute;
-          const attributeRes = await 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] = attributeRes?.uid ?? '';
+          // skip creating preset attributes, as they are already present in the system
+          if (attribute.__type === 'PRESET') {
+            continue;
+          }
+          try {
+            const attributeRes = await 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] = attributeRes?.uid ?? '';
+          } catch (error) {
+            this.log(this.config, `Failed to create attribute ${name}!`, 'error');
+            this.log(this.config, error, 'error');
+          }
         }
 
         fsUtil.writeFile(this.attributesUidMapperPath, this.attributesUidMapper);

package/src/import/audiences.ts

@@ -10,24 +10,32 @@ export default class Audiences extends PersonalizationAdapter<ImportConfig> {
   private attributesMapperPath: string;
   private audiencesUidMapperPath: string;
   private audiencesUidMapper: Record<string, unknown>;
-  private personalizationConfig: ImportConfig['modules']['personalization'];
-  private audienceConfig: ImportConfig['modules']['personalization']['audiences'];
-  public attributeConfig: ImportConfig['modules']['personalization']['attributes'];
+  private personalizeConfig: ImportConfig['modules']['personalize'];
+  private audienceConfig: ImportConfig['modules']['personalize']['audiences'];
+  public attributeConfig: ImportConfig['modules']['personalize']['attributes'];
 
   constructor(public readonly config: ImportConfig, private readonly log: LogType = console.log) {
     const conf: APIConfig = {
       config,
-      baseURL: config.modules.personalization.baseURL[config.region.name],
-      headers: { 'X-Project-Uid': config.modules.personalization.project_id, authtoken: config.auth_token },
+      baseURL: config.modules.personalize.baseURL[config.region.name],
+      headers: { 'X-Project-Uid': config.modules.personalize.project_id },
     };
     super(Object.assign(config, conf));
-    this.personalizationConfig = this.config.modules.personalization;
-    this.audienceConfig = this.personalizationConfig.audiences;
-    this.attributeConfig = this.personalizationConfig.attributes;
-    this.mapperDirPath = resolve(sanitizePath(this.config.backupDir), 'mapper', sanitizePath(this.personalizationConfig.dirName));
+    this.personalizeConfig = this.config.modules.personalize;
+    this.audienceConfig = this.personalizeConfig.audiences;
+    this.attributeConfig = this.personalizeConfig.attributes;
+    this.mapperDirPath = resolve(
+      sanitizePath(this.config.backupDir),
+      'mapper',
+      sanitizePath(this.personalizeConfig.dirName),
+    );
     this.audienceMapperDirPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.audienceConfig.dirName));
     this.audiencesUidMapperPath = resolve(sanitizePath(this.audienceMapperDirPath), 'uid-mapping.json');
-    this.attributesMapperPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.attributeConfig.dirName), 'uid-mapping.json');
+    this.attributesMapperPath = resolve(
+      sanitizePath(this.mapperDirPath),
+      sanitizePath(this.attributeConfig.dirName),
+      'uid-mapping.json',
+    );
     this.audiencesUidMapper = {};
   }
 
@@ -36,10 +44,15 @@ export default class Audiences extends PersonalizationAdapter<ImportConfig> {
    */
   async import() {
     this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Audiences' }), 'info');
-
+    await this.init();
     await fsUtil.makeDirectory(this.audienceMapperDirPath);
     const { dirName, fileName } = this.audienceConfig;
-    const audiencesPath = resolve(sanitizePath(this.config.data), sanitizePath(this.personalizationConfig.dirName), sanitizePath(dirName), sanitizePath(fileName));
+    const audiencesPath = resolve(
+      sanitizePath(this.config.data),
+      sanitizePath(this.personalizeConfig.dirName),
+      sanitizePath(dirName),
+      sanitizePath(fileName),
+    );
 
     if (existsSync(audiencesPath)) {
       try {
@@ -48,14 +61,19 @@ export default class Audiences extends PersonalizationAdapter<ImportConfig> {
 
         for (const audience of audiences) {
           let { name, definition, description, uid } = audience;
-          //check whether reference attributes exists or not
-          if (definition.rules?.length) {
-            definition.rules = lookUpAttributes(definition.rules, attributesUid);
+          try {
+            //check whether reference attributes exists or not
+            if (definition.rules?.length) {
+              definition.rules = lookUpAttributes(definition.rules, attributesUid);
+            }
+            const audienceRes = await 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] = audienceRes?.uid ?? '';
+          } catch (error) {
+            this.log(this.config, `Failed to create audience uid: ${uid}, name: ${name}`, 'error');
+            this.log(this.config, error, 'error');
           }
-          const audienceRes = await 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] = audienceRes?.uid ?? '';
         }
 
         fsUtil.writeFile(this.audiencesUidMapperPath, this.audiencesUidMapper);

package/src/import/events.ts

@@ -9,19 +9,23 @@ export default class Events extends PersonalizationAdapter<ImportConfig> {
   private eventMapperDirPath: string;
   private eventsUidMapperPath: string;
   private eventsUidMapper: Record<string, unknown>;
-  private personalizationConfig: ImportConfig['modules']['personalization'];
-  private eventsConfig: ImportConfig['modules']['personalization']['events'];
+  private personalizeConfig: ImportConfig['modules']['personalize'];
+  private eventsConfig: ImportConfig['modules']['personalize']['events'];
 
   constructor(public readonly config: ImportConfig, private readonly log: LogType = console.log) {
     const conf: APIConfig = {
       config,
-      baseURL: config.modules.personalization.baseURL[config.region.name],
-      headers: { 'X-Project-Uid': config.modules.personalization.project_id, authtoken: config.auth_token },
+      baseURL: config.modules.personalize.baseURL[config.region.name],
+      headers: { 'X-Project-Uid': config.modules.personalize.project_id },
     };
     super(Object.assign(config, conf));
-    this.personalizationConfig = this.config.modules.personalization;
-    this.eventsConfig = this.personalizationConfig.events;
-    this.mapperDirPath = resolve(sanitizePath(this.config.backupDir), 'mapper', sanitizePath(this.personalizationConfig.dirName));
+    this.personalizeConfig = this.config.modules.personalize;
+    this.eventsConfig = this.personalizeConfig.events;
+    this.mapperDirPath = resolve(
+      sanitizePath(this.config.backupDir),
+      'mapper',
+      sanitizePath(this.personalizeConfig.dirName),
+    );
     this.eventMapperDirPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.eventsConfig.dirName));
     this.eventsUidMapperPath = resolve(sanitizePath(this.eventMapperDirPath), 'uid-mapping.json');
     this.eventsUidMapper = {};
@@ -32,10 +36,15 @@ export default class Events extends PersonalizationAdapter<ImportConfig> {
    */
   async import() {
     this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Events' }), 'info');
-
+    await this.init();
     await fsUtil.makeDirectory(this.eventMapperDirPath);
     const { dirName, fileName } = this.eventsConfig;
-    const eventsPath = resolve(sanitizePath(this.config.data), sanitizePath(this.personalizationConfig.dirName), sanitizePath(dirName), sanitizePath(fileName));
+    const eventsPath = resolve(
+      sanitizePath(this.config.data),
+      sanitizePath(this.personalizeConfig.dirName),
+      sanitizePath(dirName),
+      sanitizePath(fileName),
+    );
 
     if (existsSync(eventsPath)) {
       try {
@@ -43,8 +52,13 @@ export default class Events extends PersonalizationAdapter<ImportConfig> {
 
         for (const event of events) {
           const { key, description, uid } = event;
-          const eventsResponse = await this.createEvents({ key, description });
-          this.eventsUidMapper[uid] = eventsResponse?.uid ?? '';
+          try {
+            const eventsResponse = await this.createEvents({ key, description });
+            this.eventsUidMapper[uid] = eventsResponse?.uid ?? '';
+          } catch (error) {
+            this.log(this.config, `failed to create event uid: ${uid}`, 'error');
+            this.log(this.config, error, 'error');
+          }
         }
 
         fsUtil.writeFile(this.eventsUidMapperPath, this.eventsUidMapper);

package/src/import/experiences.ts

@@ -4,8 +4,14 @@ import values from 'lodash/values';
 import cloneDeep from 'lodash/cloneDeep';
 import { sanitizePath } from '@contentstack/cli-utilities';
 import { PersonalizationAdapter, fsUtil, lookUpAudiences, lookUpEvents } from '../utils';
-import { APIConfig, ImportConfig, ExperienceStruct, CreateExperienceInput, LogType } from '../types';
-
+import {
+  APIConfig,
+  ImportConfig,
+  ExperienceStruct,
+  CreateExperienceInput,
+  LogType,
+  CreateExperienceVersionInput,
+} from '../types';
 export default class Experiences extends PersonalizationAdapter<ImportConfig> {
   private createdCTs: string[];
   private mapperDirPath: string;
@@ -29,43 +35,56 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
   private cmsVariantGroups: Record<string, unknown>;
   private experiencesUidMapper: Record<string, string>;
   private pendingVariantAndVariantGrpForExperience: string[];
-  private personalizationConfig: ImportConfig['modules']['personalization'];
-  private audienceConfig: ImportConfig['modules']['personalization']['audiences'];
-  private experienceConfig: ImportConfig['modules']['personalization']['experiences'];
+  private audiencesUid: Record<string, string>;
+  private eventsUid: Record<string, string>;
+  private personalizeConfig: ImportConfig['modules']['personalize'];
+  private audienceConfig: ImportConfig['modules']['personalize']['audiences'];
+  private experienceConfig: ImportConfig['modules']['personalize']['experiences'];
 
   constructor(public readonly config: ImportConfig, private readonly log: LogType = console.log) {
     const conf: APIConfig = {
       config,
-      baseURL: config.modules.personalization.baseURL[config.region.name],
-      headers: { 'X-Project-Uid': config.modules.personalization.project_id, authtoken: config.auth_token },
+      baseURL: config.modules.personalize.baseURL[config.region.name],
+      headers: { 'X-Project-Uid': config.modules.personalize.project_id},
       cmaConfig: {
         baseURL: config.region.cma + `/v3`,
-        headers: { authtoken: config.auth_token, api_key: config.apiKey },
+        headers: { api_key: config.apiKey },
       },
     };
     super(Object.assign(config, conf));
-    this.personalizationConfig = this.config.modules.personalization;
+    this.personalizeConfig = this.config.modules.personalize;
     this.experiencesDirPath = resolve(
       sanitizePath(this.config.data),
-      sanitizePath(this.personalizationConfig.dirName),
-      sanitizePath(this.personalizationConfig.experiences.dirName),
+      sanitizePath(this.personalizeConfig.dirName),
+      sanitizePath(this.personalizeConfig.experiences.dirName),
+    );
+    this.experiencesPath = join(
+      sanitizePath(this.experiencesDirPath),
+      sanitizePath(this.personalizeConfig.experiences.fileName),
+    );
+    this.experienceConfig = this.personalizeConfig.experiences;
+    this.audienceConfig = this.personalizeConfig.audiences;
+    this.mapperDirPath = resolve(
+      sanitizePath(this.config.backupDir),
+      'mapper',
+      sanitizePath(this.personalizeConfig.dirName),
     );
-    this.experiencesPath = join(sanitizePath(this.experiencesDirPath), sanitizePath(this.personalizationConfig.experiences.fileName));
-    this.experienceConfig = this.personalizationConfig.experiences;
-    this.audienceConfig = this.personalizationConfig.audiences;
-    this.mapperDirPath = resolve(sanitizePath(this.config.backupDir), 'mapper', sanitizePath(this.personalizationConfig.dirName));
     this.expMapperDirPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.experienceConfig.dirName));
     this.experiencesUidMapperPath = resolve(sanitizePath(this.expMapperDirPath), 'uid-mapping.json');
     this.cmsVariantGroupPath = resolve(sanitizePath(this.expMapperDirPath), 'cms-variant-groups.json');
     this.cmsVariantPath = resolve(sanitizePath(this.expMapperDirPath), 'cms-variants.json');
-    this.audiencesMapperPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.audienceConfig.dirName), 'uid-mapping.json');
+    this.audiencesMapperPath = resolve(
+      sanitizePath(this.mapperDirPath),
+      sanitizePath(this.audienceConfig.dirName),
+      'uid-mapping.json',
+    );
     this.eventsMapperPath = resolve(sanitizePath(this.mapperDirPath), 'events', 'uid-mapping.json');
     this.failedCmsExpPath = resolve(sanitizePath(this.expMapperDirPath), 'failed-cms-experience.json');
     this.failedCmsExpPath = resolve(sanitizePath(this.expMapperDirPath), 'failed-cms-experience.json');
     this.experienceCTsPath = resolve(sanitizePath(this.experiencesDirPath), 'experiences-content-types.json');
     this.experienceVariantsIdsPath = resolve(
       sanitizePath(this.config.data),
-      sanitizePath(this.personalizationConfig.dirName),
+      sanitizePath(this.personalizeConfig.dirName),
       sanitizePath(this.experienceConfig.dirName),
       'experiences-variants-ids.json',
     );
@@ -79,6 +98,8 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
     this.pendingVariantAndVariantGrpForExperience = [];
     this.cTsSuccessPath = resolve(sanitizePath(this.config.backupDir), 'mapper', 'content_types', 'success.json');
     this.createdCTs = [];
+    this.audiencesUid = (fsUtil.readFile(this.audiencesMapperPath, true) as Record<string, string>) || {};
+    this.eventsUid = (fsUtil.readFile(this.eventsMapperPath, true) as Record<string, string>) || {};
   }
 
   /**
@@ -86,25 +107,31 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
    */
   async import() {
     this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Experiences' }), 'info');
-
+    await this.init();
     await fsUtil.makeDirectory(this.expMapperDirPath);
 
     if (existsSync(this.experiencesPath)) {
       try {
         const experiences = fsUtil.readFile(this.experiencesPath, true) as ExperienceStruct[];
-        const audiencesUid = (fsUtil.readFile(this.audiencesMapperPath, true) as Record<string, string>) || {};
-        const eventsUid = (fsUtil.readFile(this.eventsMapperPath, true) as Record<string, string>) || {};
 
         for (const experience of experiences) {
           const { uid, ...restExperienceData } = experience;
           //check whether reference audience exists or not that referenced in variations having __type equal to AudienceBasedVariation & targeting
-          let experienceReqObj: CreateExperienceInput = lookUpAudiences(restExperienceData, audiencesUid);
+          let experienceReqObj: CreateExperienceInput = lookUpAudiences(restExperienceData, this.audiencesUid);
           //check whether events exists or not that referenced in metrics
-          experienceReqObj = lookUpEvents(experienceReqObj, eventsUid);
+          experienceReqObj = lookUpEvents(experienceReqObj, this.eventsUid);
 
-          const expRes = await this.createExperience(experienceReqObj);
+          const expRes = (await this.createExperience(experienceReqObj)) as ExperienceStruct;
           //map old experience uid to new experience uid
           this.experiencesUidMapper[uid] = expRes?.uid ?? '';
+
+          try {
+            // import versions of experience
+            await 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');
+          }
         }
         fsUtil.writeFile(this.experiencesUidMapperPath, this.experiencesUidMapper);
         this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Experiences' }), 'info');
@@ -117,9 +144,10 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
         if (jobRes)
           this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Variant & Variant groups' }), 'info');
 
-        if (this.personalizationConfig.importData) {
+        if (this.personalizeConfig.importData) {
           this.log(this.config, this.messages.UPDATING_CT_IN_EXP, 'info');
           await this.attachCTsInExperience();
+          this.log(this.config, this.messages.UPDATED_CT_IN_EXP, 'info');
         }
 
         await this.createVariantIdMapper();
@@ -131,9 +159,71 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
   }
 
   /**
-   * 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.
+   * function import experience versions from a JSON file and creates them in the project.
+   */
+  async importExperienceVersions(experience: ExperienceStruct, oldExperienceUid: string) {
+    const versionsPath = resolve(sanitizePath(this.experiencesDirPath), 'versions', `${sanitizePath(oldExperienceUid)}.json`);
+
+    if (!existsSync(versionsPath)) {
+      return;
+    }
+
+    const versions = fsUtil.readFile(versionsPath, true) as ExperienceStruct[];
+    const versionMap: Record<string, CreateExperienceVersionInput | undefined> = {
+      ACTIVE: undefined,
+      DRAFT: undefined,
+      PAUSE: undefined,
+    };
+
+    // Process each version and map them by status
+    versions.forEach((version) => {
+      let versionReqObj = lookUpAudiences(version, this.audiencesUid) as CreateExperienceVersionInput;
+      versionReqObj = lookUpEvents(version, this.eventsUid) as CreateExperienceVersionInput;
+
+      if (versionReqObj && versionReqObj.status) {
+        versionMap[versionReqObj.status] = versionReqObj;
+      }
+    });
+
+    // Prioritize updating or creating versions based on the order: ACTIVE -> DRAFT -> PAUSE
+    return await this.handleVersionUpdateOrCreate(experience, versionMap);
+  }
+
+  // Helper method to handle version update or creation logic
+  private async handleVersionUpdateOrCreate(
+    experience: ExperienceStruct,
+    versionMap: Record<string, CreateExperienceVersionInput | undefined>,
+  ) {
+    const { ACTIVE, DRAFT, PAUSE } = versionMap;
+    let latestVersionUsed = false;
+
+    if (ACTIVE) {
+      await this.updateExperienceVersion(experience.uid, experience.latestVersion, ACTIVE);
+      latestVersionUsed = true;
+    }
+
+    if (DRAFT) {
+      if (latestVersionUsed) {
+        await this.createExperienceVersion(experience.uid, DRAFT);
+      } else {
+        await this.updateExperienceVersion(experience.uid, experience.latestVersion, DRAFT);
+        latestVersionUsed = true;
+      }
+    }
+
+    if (PAUSE) {
+      if (latestVersionUsed) {
+        await this.createExperienceVersion(experience.uid, PAUSE);
+      } else {
+        await this.updateExperienceVersion(experience.uid, experience.latestVersion, PAUSE);
+      }
+    }
+  }
+
+  /**
+   * function to validate if all variant groups and variants have been created using personalize background job
+   * store the variant groups data in mapper/personalize/experiences/cms-variant-groups.json and the variants data
+   * in mapper/personalize/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
    */
@@ -160,7 +250,7 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
           );
           return this.validateVariantGroupAndVariantsCreated(retryCount);
         } else {
-          this.log(this.config, this.messages.PERSONALIZATION_JOB_FAILURE, 'error');
+          this.log(this.config, this.messages.PERSONALIZE_JOB_FAILURE, 'error');
           fsUtil.writeFile(this.failedCmsExpPath, this.pendingVariantAndVariantGrpForExperience);
           return false;
         }
@@ -185,8 +275,8 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
         Object.entries(this.experiencesUidMapper).map(async ([oldExpUid, newExpUid]) => {
           if (experienceCTsMap[oldExpUid]?.length) {
             // Filter content types that were created
-            const updatedContentTypes = experienceCTsMap[oldExpUid].filter((ct: any) =>
-              this.createdCTs.includes(ct?.uid),
+            const updatedContentTypes = experienceCTsMap[oldExpUid].filter(
+              (ct: any) => this.createdCTs.includes(ct?.uid) && ct.status === 'linked',
             );
             if (updatedContentTypes?.length) {
               const { variant_groups: [variantGroup] = [] } =

package/src/import/project.ts

@@ -9,14 +9,14 @@ export default class Project extends PersonalizationAdapter<ImportConfig> {
   constructor(public readonly config: ImportConfig, private readonly log: LogType = console.log) {
     const conf: APIConfig = {
       config,
-      baseURL: config.modules.personalization.baseURL[config.region.name],
-      headers: { organization_uid: config.org_uid, authtoken: config.auth_token },
+      baseURL: config.modules.personalize.baseURL[config.region.name],
+      headers: { organization_uid: config.org_uid },
     };
     super(Object.assign(config, conf));
     this.projectMapperFolderPath = pResolve(
       sanitizePath(this.config.backupDir),
       'mapper',
-      sanitizePath(this.config.modules.personalization.dirName),
+      sanitizePath(this.config.modules.personalize.dirName),
       'projects',
     );
   }
@@ -26,19 +26,19 @@ export default class Project extends PersonalizationAdapter<ImportConfig> {
    * data.
    */
   async import() {
-    const personalization = this.config.modules.personalization;
-    const { dirName, fileName } = personalization.projects;
-    const projectPath = join(sanitizePath(this.config.data), sanitizePath(personalization.dirName), sanitizePath(dirName), sanitizePath(fileName));
-
+    const personalize = this.config.modules.personalize;
+    const { dirName, fileName } = personalize.projects;
+    const projectPath = join(sanitizePath(this.config.data), sanitizePath(personalize.dirName), sanitizePath(dirName), sanitizePath(fileName));
+    
     if (existsSync(projectPath)) {
       const projects = JSON.parse(readFileSync(projectPath, 'utf8')) as CreateProjectInput[];
 
       if (!projects || projects.length < 1) {
-        this.config.modules.personalization.importData = false; // Stop personalization import if stack not connected to any project
+        this.config.modules.personalize.importData = false; // Stop personalize import if stack not connected to any project
         this.log(this.config, 'No project found!', 'info');
         return;
       }
-
+      await this.init();
       for (const project of projects) {
         const createProject = async (newName: void | string): Promise<ProjectStruct> => {
           return await this.createProject({
@@ -46,7 +46,7 @@ export default class Project extends PersonalizationAdapter<ImportConfig> {
             description: project.description,
             connectedStackApiKey: this.config.apiKey,
           }).catch(async (error) => {
-            if (error === 'personalization.PROJECTS.DUPLICATE_NAME') {
+            if (error.includes('personalization.PROJECTS.DUPLICATE_NAME') || error.includes('personalize.PROJECTS.DUPLICATE_NAME')) {
               const projectName = await askProjectName('Copy Of ' + (newName || project.name));
               return await createProject(projectName);
             }
@@ -56,15 +56,15 @@ export default class Project extends PersonalizationAdapter<ImportConfig> {
         };
 
         const projectRes = await createProject(this.config.personalizeProjectName);
-        this.config.modules.personalization.project_id = projectRes.uid;
-        this.config.modules.personalization.importData = true;
+        this.config.modules.personalize.project_id = projectRes.uid;
+        this.config.modules.personalize.importData = true;
 
         await fsUtil.makeDirectory(this.projectMapperFolderPath);
         fsUtil.writeFile(pResolve(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.config.modules.personalize.importData = false; // Stop personalize import if stack not connected to any project
       this.log(this.config, 'No project found!', 'info');
     }
   }