@contentstack/cli-variants 0.0.1-alpha → 1.1.0

package/src/import/variant-entries.ts

@@ -29,7 +29,7 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
   public entriesMapperPath: string;
   public variantEntryBasePath!: string;
   public variantIdList!: Record<string, unknown>;
-  public personalizationConfig: ImportConfig['modules']['personalization'];
+  public personalizeConfig: ImportConfig['modules']['personalize'];
 
   public taxonomies!: Record<string, unknown>;
   public assetUrlMapper!: Record<string, any>;
@@ -49,15 +49,23 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
       headers: {
         api_key: config.apiKey,
         branch: config.branchName,
-        authtoken: config.auth_token,
         organization_uid: config.org_uid,
-        'X-Project-Uid': config.modules.personalization.project_id,
+        'X-Project-Uid': config.modules.personalize.project_id,
       },
-    }; 
+    };
     super(Object.assign(omit(config, ['helpers']), conf));
-    this.entriesMapperPath = resolve(sanitizePath(config.backupDir), sanitizePath(config.branchName || ''), 'mapper', 'entries');
-    this.personalizationConfig = this.config.modules.personalization;
-    this.entriesDirPath = resolve(sanitizePath(config.backupDir), sanitizePath(config.branchName || ''), sanitizePath(config.modules.entries.dirName));
+    this.entriesMapperPath = resolve(
+      sanitizePath(config.backupDir),
+      sanitizePath(config.branchName || ''),
+      'mapper',
+      'entries',
+    );
+    this.personalizeConfig = this.config.modules.personalize;
+    this.entriesDirPath = resolve(
+      sanitizePath(config.backupDir),
+      sanitizePath(config.branchName || ''),
+      sanitizePath(config.modules.entries.dirName),
+    );
     this.failedVariantPath = resolve(sanitizePath(this.entriesMapperPath), 'failed-entry-variants.json');
     this.failedVariantEntries = new Map();
   }
@@ -75,8 +83,8 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
     const variantIdPath = resolve(
       sanitizePath(this.config.backupDir),
       'mapper',
-      sanitizePath(this.personalizationConfig.dirName),
-      sanitizePath(this.personalizationConfig.experiences.dirName),
+      sanitizePath(this.personalizeConfig.dirName),
+      sanitizePath(this.personalizeConfig.experiences.dirName),
       'variants-uid-mapping.json',
     );
 
@@ -107,7 +115,12 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
       'terms',
       'success.json',
     );
-    const marketplaceAppMapperPath = resolve(sanitizePath(this.config.backupDir), 'mapper', 'marketplace_apps', 'uid-mapping.json');
+    const marketplaceAppMapperPath = resolve(
+      sanitizePath(this.config.backupDir),
+      'mapper',
+      'marketplace_apps',
+      'uid-mapping.json',
+    );
     const envPath = resolve(sanitizePath(this.config.backupDir), 'environments', 'environments.json');
     // NOTE Read and store list of variant IDs
     this.variantIdList = (fsUtil.readFile(variantIdPath, true) || {}) as Record<string, unknown>;
@@ -124,7 +137,8 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
     this.assetUidMapper = (fsUtil.readFile(assetUidMapperPath, true) || {}) as Record<string, any>;
     this.assetUrlMapper = (fsUtil.readFile(assetUrlMapperPath, true) || {}) as Record<string, any>;
     this.environments = (fsUtil.readFile(envPath, true) || {}) as Record<string, any>;
-
+    // set the token
+    await this.variantInstance.init();
     for (const entriesForVariant of entriesForVariants) {
       await this.importVariantEntries(entriesForVariant);
     }
@@ -141,9 +155,22 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
     const { content_type, locale, entry_uid } = entriesForVariant;
     const ctConfig = this.config.modules['content-types'];
     const contentType: ContentTypeStruct = JSON.parse(
-      readFileSync(resolve(sanitizePath(this.config.backupDir), sanitizePath(ctConfig.dirName), `${sanitizePath(content_type)}.json`), 'utf8'),
+      readFileSync(
+        resolve(
+          sanitizePath(this.config.backupDir),
+          sanitizePath(ctConfig.dirName),
+          `${sanitizePath(content_type)}.json`,
+        ),
+        'utf8',
+      ),
+    );
+    const variantEntryBasePath = join(
+      sanitizePath(this.entriesDirPath),
+      sanitizePath(content_type),
+      sanitizePath(locale),
+      sanitizePath(variantEntry.dirName),
+      sanitizePath(entry_uid),
     );
-    const variantEntryBasePath = join(sanitizePath(this.entriesDirPath), sanitizePath(content_type), sanitizePath(locale), sanitizePath(variantEntry.dirName), sanitizePath(entry_uid));
     const fs = new FsUtility({ basePath: variantEntryBasePath });
 
     for (const _ in fs.indexFileContent) {
@@ -202,7 +229,7 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
           log(this.config, error, 'error');
         };
         // NOTE Find new variant Id by old Id
-        const variant_id = this.variantIdList[variantEntry.variant_id] as string;
+        const variantId = this.variantIdList[variantEntry._variant._uid] as string;
         // NOTE Replace all the relation data UID's
         variantEntry = this.handleVariantEntryRelationalData(contentType, variantEntry);
         const changeSet = this.serializeChangeSet(variantEntry);
@@ -211,19 +238,19 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
           ...changeSet,
         };
 
-        if (variant_id) {
+        if (variantId) {
           const promise = this.variantInstance.createVariantEntry(
             createVariantReq,
             {
               locale,
               entry_uid: entryUid,
-              variant_id,
+              variant_id: variantId,
               content_type_uid: content_type,
             },
             {
               reject: onReject.bind(this),
               resolve: onSuccess.bind(this),
-              variantUid: variantEntry.uid,
+              variantUid: variantId,
               log: log,
             },
           );
@@ -341,7 +368,7 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
    * @param variantEntry - The entry variant to update.
    */
   updateFileFields(variantEntry: VariantEntryStruct) {
-    const setValue = (currentObj: VariantEntryStruct, keys: Array<string>) => {
+    const setValue = (currentObj: VariantEntryStruct, keys: string[]) => {
       if (!currentObj || keys.length === 0) return;
 
       const [firstKey, ...restKeys] = keys;
@@ -353,7 +380,14 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
       } else if (currentObj && typeof currentObj === 'object') {
         if (firstKey in currentObj) {
           if (keys.length === 1) {
-            currentObj[firstKey] = { uid: currentObj[firstKey], filename: 'dummy.jpeg' };
+            // Check if the current property is already an object with uid and filename
+            const existingValue = currentObj[firstKey];
+
+            if (existingValue && typeof existingValue === 'object' && existingValue.uid) {
+              currentObj[firstKey] = { uid: existingValue.uid, filename: 'dummy.jpeg' };
+            } else {
+              currentObj[firstKey] = { uid: currentObj[firstKey], filename: 'dummy.jpeg' };
+            }
           } else {
             setValue(currentObj[firstKey], restKeys);
           }
@@ -361,13 +395,12 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
       }
     };
 
-    const pathsToUpdate = variantEntry?._metadata?.references
-      .filter((ref: any) => ref._content_type_uid === 'sys_assets')
-      .map((ref: any) => ref.path);
+    const pathsToUpdate =
+      variantEntry?._metadata?.references
+        ?.filter((ref: any) => ref._content_type_uid === 'sys_assets')
+        .map((ref: any) => ref.path) || [];
 
-    if (pathsToUpdate) {
-      pathsToUpdate.forEach((path: string) => setValue(variantEntry, path.split('.')));
-    }
+    pathsToUpdate.forEach((path: string) => setValue(variantEntry, path.split('.')));
   }
 
   /**
@@ -379,24 +412,25 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
    */
   async publishVariantEntries(batch: VariantEntryStruct[], entryUid: string, content_type: string) {
     const allPromise = [];
+    log(
+      this.config,
+      `Publishing variant entries for entry uid '${entryUid}' of Content Type '${content_type}'`,
+      'info',
+    );
     for (let [, variantEntry] of entries(batch)) {
-      const variantUid = variantEntry.uid;
-      const oldVariantUid = variantEntry.variant_id || '';
+      const variantEntryUID = variantEntry.uid;
+      const oldVariantUid = variantEntry._variant._uid || '';
       const newVariantUid = this.variantIdList[oldVariantUid] as string;
 
       if (!newVariantUid) {
-        log(
-          this.config,
-          `${this.messages.VARIANT_ID_NOT_FOUND}. Skipping entry variant publish for ${variantUid}`,
-          'info',
-        );
+        log(this.config, `${this.messages.VARIANT_ID_NOT_FOUND}. Skipping entry variant publish`, 'info');
         continue;
       }
 
-      if (this.failedVariantEntries.has(variantUid)) {
+      if (this.failedVariantEntries.has(variantEntryUID)) {
         log(
           this.config,
-          `${this.messages.VARIANT_UID_NOT_FOUND}. Skipping entry variant publish for ${variantUid}`,
+          `${this.messages.VARIANT_UID_NOT_FOUND}. Skipping entry variant publish for ${variantEntryUID}`,
           'info',
         );
         continue;
@@ -423,11 +457,9 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
         entry: {
           environments,
           locales,
-          publish_with_base_entry: false,
           variants: [{ uid: newVariantUid, version: 1 }],
         },
         locale: variantEntry.locale,
-        version: 1,
       };
 
       const promise = this.variantInstance.publishVariantEntry(
@@ -440,13 +472,14 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
           reject: onReject.bind(this),
           resolve: onSuccess.bind(this),
           log: log,
-          variantUid,
+          variantUid: newVariantUid,
         },
       );
 
       allPromise.push(promise);
     }
     await Promise.allSettled(allPromise);
+    log(this.config, `Published variant entries for entry uid '${entryUid}' of Content Type '${content_type}'`, 'info');
   }
 
   /**

package/src/messages/index.ts

@@ -23,7 +23,7 @@ const expImportMsg = {
   UPDATING_CT_IN_EXP: 'Updating content types in experiences...',
   UPDATED_CT_IN_EXP: 'Successfully updated content types in experiences!',
   VALIDATE_VARIANT_AND_VARIANT_GRP: 'Validating variant group and variants creation...',
-  PERSONALIZATION_JOB_FAILURE: 'Something went wrong with personalization background job! Failed to fetch some variant & variant groups',
+  PERSONALIZE_JOB_FAILURE: 'Something went wrong! Failed to fetch some variant and variant groups.',
 };
 
 const messages: typeof errors & typeof commonMsg & typeof migrationMsg & typeof variantEntry & typeof expImportMsg = {
@@ -50,7 +50,8 @@ function $t(msg: string, args: Record<string, string>): string {
 
     for (const key of Object.keys(args)) {
       const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      msg = msg.replace(new RegExp(`{${escapedKey}}`, 'g'), args[key] || escapedKey);
+      const placeholder = `{${escapedKey}}`;
+      msg = msg.split(placeholder).join(args[key]);
     }
 
     return msg;

package/src/types/export-config.ts

@@ -20,7 +20,7 @@ export type Modules =
   | 'labels'
   | 'marketplace-apps'
   | 'taxonomies'
-  | 'personalization';
+  | 'personalize';
 
 export type branch = {
   uid: string;
@@ -155,7 +155,7 @@ export interface DefaultConfig {
         include_publish_details: boolean;
       } & AnyProperty;
     } & AnyProperty;
-    personalization: {
+    personalize: {
       dirName: string;
       baseURL: Record<string, string>;
     } & AnyProperty;
@@ -269,7 +269,7 @@ export interface ExportConfig extends DefaultConfig {
   region: any;
 }
 
-export interface PersonalizationConfig {
+export interface PersonalizeConfig {
   dirName: string;
   baseURL: Record<string, string>;
 }

package/src/types/import-config.ts

@@ -12,7 +12,7 @@ export interface ImportDefaultConfig extends AnyProperty {
       dirName: string;
       fileName: string;
     };
-    personalization: {
+    personalize: {
       baseURL: Record<string, string>;
       dirName: string;
       importData: boolean;

package/src/types/personalization-api-adapter.ts

@@ -130,6 +130,18 @@ export type ExperienceStruct = {
   content_types?: string[];
 } & AnyProperty;
 
+export interface CreateExperienceVersionInput {
+  name: string;
+  __type: string;
+  description: string;
+  targeting?: ExpTargeting;
+  variations: ExpVariations[];
+  variationSplit?: string;
+  metrics?: ExpMetric[];
+  status: string;
+  metadata?: object;
+  variants: Array<ExpVariations>;
+}
 export interface CreateExperienceInput {
   name: string;
   __type: string;
@@ -140,6 +152,7 @@ export interface CreateExperienceInput {
   metrics?: ExpMetric[];
   status: string;
   metadata?: object;
+  variants?: Array<ExpVariations>;
 }
 
 export interface UpdateExperienceInput {
@@ -193,5 +206,5 @@ export interface Personalization<T> extends AdapterHelperInterface<T, HttpClient
 
   updateCTsInExperience(experience: UpdateExperienceInput, experienceUid: string): Promise<CMSExperienceStruct | void>;
 
-  handleVariantAPIRes(res: any): VariantAPIRes;
+  handleVariantAPIRes(res: any): Promise<VariantAPIRes>;
 }

package/src/types/variant-api-adapter.ts

@@ -42,6 +42,8 @@ export type VariantOptions = VariantsOption & {
 };
 
 export interface VariantInterface<T, ApiClient> extends AdapterHelperInterface<T, ApiClient> {
+  init(): Promise<void>;
+
   variantEntry(options: VariantOptions): Promise<{ entry: Record<string, any> }>;
 
   variantEntries(options: VariantsOption): Promise<{ entries?: Record<string, any>[] | unknown[] } | void>;
@@ -52,5 +54,5 @@ export interface VariantInterface<T, ApiClient> extends AdapterHelperInterface<T
     apiParams: Record<string, any>,
   ): Promise<VariantEntryStruct | string | void>;
 
-  handleVariantAPIRes(res: APIResponse): VariantEntryStruct | { entries: VariantEntryStruct[]; count: number } | string;
+  handleVariantAPIRes(res: APIResponse): Promise<VariantEntryStruct | { entries: VariantEntryStruct[]; count: number } | string>;
 }

package/src/types/variant-entry.ts

@@ -3,11 +3,11 @@ import { AnyProperty } from './utils';
 export type VariantEntryStruct = {
   uid: string;
   title: string;
-  variant_id: string;
   locale: string;
   _version: number;
   _variant: {
-    uid: string;
+    _uid: string;
+    _instance_uid: string;
     _change_set: string[];
     _base_entry_version: number;
   };
@@ -50,7 +50,6 @@ export type PublishVariantEntryDto = {
   entry: {
     environments: string[];
     locales: string[];
-    publish_with_base_entry: boolean;
     variants: {
       uid: string;
       version?: number;

package/src/utils/attributes-helper.ts

@@ -12,8 +12,8 @@ export const lookUpAttributes = (attributeRules: Record<string, any>[], attribut
       // Check if attribute reference exists in attributesUid
       const attributeRef = rule.attribute?.ref;
       const attributeType = rule.attribute['__type'];
-      // check if type is UserAttributeReference
-      if (attributeType === 'UserAttributeReference') {
+      // check if type is CustomAttributeReference
+      if (attributeType === 'CustomAttributeReference') {
         if (attributeRef && attributesUid.hasOwnProperty(attributeRef) && attributesUid[attributeRef]) {
           rule.attribute.ref = attributesUid[attributeRef];
         } else {

package/src/utils/audiences-helper.ts

@@ -1,4 +1,4 @@
-import { CreateExperienceInput } from '../types';
+import { CreateExperienceInput, CreateExperienceVersionInput } from '../types';
 
 /**
  * function for substituting an old audience UID with a new one or deleting the audience information if it does not exist
@@ -37,10 +37,20 @@ export const lookUpAudiences = (
         }
       }
     }
+  } else if (experience.variants) {
+    for (let index = experience.variants.length - 1; index >= 0; index--) {
+      const expVariations = experience.variants[index];
+      if (expVariations['__type'] === 'SegmentedVariant' && expVariations?.audiences?.length) {
+        updateAudiences(expVariations.audiences, audiencesUid);
+        if (!expVariations.audiences.length) {
+          experience.variants.splice(index, 1);
+        }
+      }
+    }
   }
 
-  // Update targeting audiences
   if (experience?.targeting?.hasOwnProperty('audience') && experience?.targeting?.audience?.audiences?.length) {
+    // Update targeting audiences
     updateAudiences(experience.targeting.audience.audiences, audiencesUid);
     if (!experience.targeting.audience.audiences.length) {
       experience.targeting = {};

package/src/utils/error-helper.ts

@@ -9,18 +9,18 @@ export function formatErrors(errors: any): string {
   for (const errorKey in errors) {
     const errorValue = errors[errorKey];
     if (Array.isArray(errorValue)) {
-      errorMessages.push(...errorValue.map((error: any) => formatError(error)));
+      errorMessages.push(...errorValue.map((error: any) => formatError(errorKey, error)));
     } else {
-      errorMessages.push(formatError(errorValue));
+      errorMessages.push(formatError(errorKey, errorValue));
     }
   }
 
   return errorMessages.join(' ');
 }
 
-function formatError(error: any): string {
-  if (typeof error === 'object') {
-    return Object.values(error).join(' ');
+function formatError(errorKey: string, error: any): string {
+  if (typeof error === 'object' && error !== null) {
+    return `${errorKey}: ${Object.values(error).join(' ')}`;
   }
-  return String(error);
+  return `${errorKey}: ${error}`;
 }

package/src/utils/logger.ts

@@ -51,9 +51,9 @@ let errorLogger: winston.Logger;
 let successTransport;
 let errorTransport;
 
-function init(_logPath: string) {
+function init(_logPath: string, module: string) {
   if (!logger || !errorLogger) {
-    const logsDir = path.resolve(sanitizePath(_logPath), 'logs', 'export');
+    const logsDir = path.resolve(sanitizePath(_logPath), 'logs', sanitizePath(module));
     // Create dir if doesn't already exist
     mkdirp.sync(logsDir);
 
@@ -131,11 +131,12 @@ function init(_logPath: string) {
 export const log = (config: ExportConfig | ImportConfig, message: any, type: 'info' | 'error' | 'success') => {
   const logsPath = config.data;
   // ignoring the type argument, as we are not using it to create a logfile anymore
+  const module = (config as ImportConfig)['backupDir'] ? 'import' : 'export';
   if (type !== 'error') {
     // removed type argument from init method
-    init(logsPath).log(message);
+    init(logsPath, module).log(message);
   } else {
-    init(logsPath).error(message);
+    init(logsPath, module).error(message);
   }
 };
 

package/src/utils/personalization-api-adapter.ts

@@ -1,5 +1,5 @@
 import { AdapterHelper } from './adapter-helper';
-import { HttpClient } from '@contentstack/cli-utilities';
+import { HttpClient, authenticationHandler } from '@contentstack/cli-utilities';
 
 import {
   ProjectStruct,
@@ -22,6 +22,7 @@ import {
   APIResponse,
   VariantGroupStruct,
   VariantGroup,
+  CreateExperienceVersionInput,
 } from '../types';
 import { formatErrors } from './error-helper';
 
@@ -30,10 +31,27 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
     super(options);
   }
 
+  async init(): Promise<void> {
+    await authenticationHandler.getAuthDetails();
+    const token = authenticationHandler.accessToken;
+    if (authenticationHandler.isOauthEnabled) {
+      this.apiClient.headers({ authorization: token });
+      if(this.adapterConfig.cmaConfig) {
+        this.cmaAPIClient?.headers({ authorization: token });
+      }
+    } else {
+      this.apiClient.headers({ authtoken: token });
+      if(this.adapterConfig.cmaConfig) {
+        this.cmaAPIClient?.headers({ authtoken: token });
+      }
+    }
+  }
+
   async projects(options: GetProjectsParams): Promise<ProjectStruct[]> {
+    await this.init();
     const getProjectEndPoint = `/projects?connectedStackApiKey=${options.connectedStackApiKey}`;
     const data = await this.apiClient.get(getProjectEndPoint);
-    return this.handleVariantAPIRes(data) as ProjectStruct[];
+    return (await this.handleVariantAPIRes(data)) as ProjectStruct[];
   }
 
   /**
@@ -48,7 +66,7 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
    */
   async createProject(project: CreateProjectInput): Promise<ProjectStruct> {
     const data = await this.apiClient.post<ProjectStruct>('/projects', project);
-    return this.handleVariantAPIRes(data) as ProjectStruct;
+    return (await this.handleVariantAPIRes(data)) as ProjectStruct;
   }
 
   /**
@@ -62,19 +80,48 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
    */
   async createAttribute(attribute: CreateAttributeInput): Promise<AttributeStruct> {
     const data = await this.apiClient.post<AttributeStruct>('/attributes', attribute);
-    return this.handleVariantAPIRes(data) as AttributeStruct;
+    return (await this.handleVariantAPIRes(data)) as AttributeStruct;
   }
 
   async getExperiences(): Promise<ExperienceStruct[]> {
     const getExperiencesEndPoint = `/experiences`;
     const data = await this.apiClient.get(getExperiencesEndPoint);
-    return this.handleVariantAPIRes(data) as ExperienceStruct[];
+    return (await this.handleVariantAPIRes(data)) as ExperienceStruct[];
   }
 
   async getExperience(experienceUid: string): Promise<ExperienceStruct | void> {
     const getExperiencesEndPoint = `/experiences/${experienceUid}`;
     const data = await this.apiClient.get(getExperiencesEndPoint);
-    return this.handleVariantAPIRes(data) as ExperienceStruct;
+    return (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+  }
+
+  async getExperienceVersions(experienceUid: string): Promise<ExperienceStruct | void> {
+    const getExperiencesVersionsEndPoint = `/experiences/${experienceUid}/versions`;
+    const data = await this.apiClient.get(getExperiencesVersionsEndPoint);
+    return (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+  }
+
+  async createExperienceVersion(
+    experienceUid: string,
+    input: CreateExperienceVersionInput,
+  ): Promise<ExperienceStruct | void> {
+    const createExperiencesVersionsEndPoint = `/experiences/${experienceUid}/versions`;
+    const data = await this.apiClient.post(createExperiencesVersionsEndPoint, input);
+    return (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+  }
+
+  async updateExperienceVersion(
+    experienceUid: string,
+    versionId: string,
+    input: CreateExperienceVersionInput,
+  ): Promise<ExperienceStruct | void> {
+    // loop through input and remove shortId from variant
+    if (input?.variants) {
+      input.variants = input.variants.map(({ shortUid, ...rest }) => rest);
+    }
+    const updateExperiencesVersionsEndPoint = `/experiences/${experienceUid}/versions/${versionId}`;
+    const data = await this.apiClient.put(updateExperiencesVersionsEndPoint, input);
+    return (await this.handleVariantAPIRes(data)) as ExperienceStruct;
   }
 
   async getVariantGroup(input: GetVariantGroupInput): Promise<VariantGroupStruct | void> {
@@ -83,7 +130,7 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
       const data = await this.cmaAPIClient
         .queryParams({ experience_uid: input.experienceUid })
         .get(getVariantGroupEndPoint);
-      return this.handleVariantAPIRes(data) as VariantGroupStruct;
+      return (await this.handleVariantAPIRes(data)) as VariantGroupStruct;
     }
   }
 
@@ -91,28 +138,28 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
     if (this.cmaAPIClient) {
       const updateVariantGroupEndPoint = `/variant_groups/${input.uid}`;
       const data = await this.cmaAPIClient.put(updateVariantGroupEndPoint, input);
-      return this.handleVariantAPIRes(data) as VariantGroup;
+      return (await this.handleVariantAPIRes(data)) as VariantGroup;
     }
   }
 
   async getEvents(): Promise<EventStruct[] | void> {
     const data = await this.apiClient.get<EventStruct>('/events');
-    return this.handleVariantAPIRes(data) as EventStruct[];
+    return (await this.handleVariantAPIRes(data)) as EventStruct[];
   }
 
   async createEvents(event: CreateEventInput): Promise<void | EventStruct> {
     const data = await this.apiClient.post<EventStruct>('/events', event);
-    return this.handleVariantAPIRes(data) as EventStruct;
+    return (await this.handleVariantAPIRes(data)) as EventStruct;
   }
 
   async getAudiences(): Promise<AudienceStruct[] | void> {
     const data = await this.apiClient.get<AudienceStruct>('/audiences');
-    return this.handleVariantAPIRes(data) as AudienceStruct[];
+    return (await this.handleVariantAPIRes(data)) as AudienceStruct[];
   }
 
   async getAttributes(): Promise<AttributeStruct[] | void> {
     const data = await this.apiClient.get<AttributeStruct>('/attributes');
-    return this.handleVariantAPIRes(data) as AttributeStruct[];
+    return (await this.handleVariantAPIRes(data)) as AttributeStruct[];
   }
 
   /**
@@ -125,7 +172,7 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
    */
   async createAudience(audience: CreateAudienceInput): Promise<void | AudienceStruct> {
     const data = await this.apiClient.post<AudienceStruct>('/audiences', audience);
-    return this.handleVariantAPIRes(data) as AudienceStruct;
+    return (await this.handleVariantAPIRes(data)) as AudienceStruct;
   }
 
   /**
@@ -138,7 +185,7 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
    */
   async createExperience(experience: CreateExperienceInput): Promise<void | ExperienceStruct> {
     const data = await this.apiClient.post<ExperienceStruct>('/experiences', experience);
-    return this.handleVariantAPIRes(data) as ExperienceStruct;
+    return (await this.handleVariantAPIRes(data)) as ExperienceStruct;
   }
 
   /**
@@ -152,7 +199,7 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
   ): Promise<void | CMSExperienceStruct> {
     const updateCTInExpEndPoint = `/experiences/${experienceUid}/cms-integration/variant-group`;
     const data = await this.apiClient.post<CMSExperienceStruct>(updateCTInExpEndPoint, experience);
-    return this.handleVariantAPIRes(data) as CMSExperienceStruct;
+    return (await this.handleVariantAPIRes(data)) as CMSExperienceStruct;
   }
 
   /**
@@ -163,7 +210,7 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
   async getCTsFromExperience(experienceUid: string): Promise<void | CMSExperienceStruct> {
     const getCTFromExpEndPoint = `/experiences/${experienceUid}/cms-integration/variant-group`;
     const data = await this.apiClient.get<CMSExperienceStruct>(getCTFromExpEndPoint);
-    return this.handleVariantAPIRes(data) as CMSExperienceStruct;
+    return (await this.handleVariantAPIRes(data)) as CMSExperienceStruct;
   }
 
   /**
@@ -172,16 +219,22 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
    * @returns The variant API response data.
    * @throws If the API response status is not within the success range, an error message is thrown.
    */
-  handleVariantAPIRes(res: APIResponse): VariantAPIRes {
+  async handleVariantAPIRes(res: APIResponse): Promise<VariantAPIRes> {
     const { status, data } = res;
 
     if (status >= 200 && status < 300) {
       return data;
     }
 
+    // Refresh the access token if it has expired
+    await authenticationHandler.refreshAccessToken(res);
+
     const errorMsg = data?.errors
       ? formatErrors(data.errors)
-      : data?.error_message || data?.message || 'Something went wrong while processing variant entries request!';
+      : data?.error ||
+        data?.error_message ||
+        data?.message ||
+        'Something went wrong while processing variant entries request!';
 
     throw errorMsg;
   }