@contentstack/cli-variants 1.2.2 → 1.3.0

package/src/utils/audiences-helper.ts

@@ -1,3 +1,4 @@
+import { log } from '@contentstack/cli-utilities';
 import { CreateExperienceInput, CreateExperienceVersionInput } from '../types';
 
 /**
@@ -6,14 +7,22 @@ import { CreateExperienceInput, CreateExperienceVersionInput } from '../types';
  * @param audiencesUid - {audiencesUid} audiences mapper data in format {<old-uid>: <new-uid>}
  */
 function updateAudiences(audiences: string[], audiencesUid: Record<string, string>) {
+  log.debug(`Updating ${audiences.length} audiences`);
+  
   for (let audienceIndex = audiences.length - 1; audienceIndex >= 0; audienceIndex--) {
     const audienceUid = audiences[audienceIndex];
+    
     if (audiencesUid.hasOwnProperty(audienceUid) && audiencesUid[audienceUid]) {
-      audiences[audienceIndex] = audiencesUid[audienceUid];
+      const newAudienceUid = audiencesUid[audienceUid];
+      log.debug(`Mapping audience: ${audienceUid} -> ${newAudienceUid}`);
+      audiences[audienceIndex] = newAudienceUid;
     } else {
+      log.warn(`Audience not found in mapping: ${audienceUid}. Removing from list.`);
       audiences.splice(audienceIndex, 1);
     }
   }
+  
+  log.debug(`Updated audiences count: ${audiences.length}`);
 }
 
 /**
@@ -26,35 +35,66 @@ export const lookUpAudiences = (
   experience: CreateExperienceInput,
   audiencesUid: Record<string, string>,
 ): CreateExperienceInput => {
+  log.debug('Starting audience lookup for experience');
+  log.debug(`Available audience mappings: ${Object.keys(audiencesUid)?.length}`);
+  
   // Update experience variations
   if (experience?.variations?.length) {
+    log.debug(`Processing ${experience.variations.length} experience variations`);
+    
     for (let index = experience.variations.length - 1; index >= 0; index--) {
       const expVariations = experience.variations[index];
+      log.debug(`Processing variation ${index + 1}/${experience.variations.length} of type: ${expVariations['__type']}`);
+      
       if (expVariations['__type'] === 'AudienceBasedVariation' && expVariations?.audiences?.length) {
+        log.debug(`Found ${expVariations.audiences.length} audiences in AudienceBasedVariation`);
         updateAudiences(expVariations.audiences, audiencesUid);
+        
         if (!expVariations.audiences.length) {
+          log.warn('No audiences remaining after mapping. Removing variation.');
           experience.variations.splice(index, 1);
         }
+      } else {
+        log.debug(`Skipping variation of type: ${expVariations['__type']}`);
       }
     }
   } else if (experience.variants) {
+    log.debug(`Processing ${experience.variants.length} experience variants`);
+    
     for (let index = experience.variants.length - 1; index >= 0; index--) {
       const expVariations = experience.variants[index];
+      log.debug(`Processing variant ${index + 1}/${experience.variants.length} of type: ${expVariations['__type']}`);
+      
       if (expVariations['__type'] === 'SegmentedVariant' && expVariations?.audiences?.length) {
+        log.debug(`Found ${expVariations.audiences.length} audiences in SegmentedVariant`);
         updateAudiences(expVariations.audiences, audiencesUid);
+        
         if (!expVariations.audiences.length) {
+          log.warn('No audiences remaining after mapping. Removing variant.');
           experience.variants.splice(index, 1);
         }
+      } else {
+        log.debug(`Skipping variant of type: ${expVariations['__type']}`);
       }
     }
+  } else {
+    log.debug('No variations or variants found in experience');
   }
 
   if (experience?.targeting?.hasOwnProperty('audience') && experience?.targeting?.audience?.audiences?.length) {
+    log.debug(`Processing ${experience.targeting.audience.audiences.length} targeting audiences`);
+    
     // Update targeting audiences
     updateAudiences(experience.targeting.audience.audiences, audiencesUid);
+    
     if (!experience.targeting.audience.audiences.length) {
+      log.warn('No targeting audiences remaining after mapping. Removing targeting.');
       experience.targeting = {};
     }
+  } else {
+    log.debug('No targeting audiences found in experience');
   }
+  
+  log.debug('Audience lookup completed for experience');
   return experience;
 };

package/src/utils/events-helper.ts

@@ -1,3 +1,4 @@
+import { log } from '@contentstack/cli-utilities';
 import { CreateExperienceInput, ExpMetric } from '../types';
 
 /**
@@ -10,17 +11,34 @@ export const lookUpEvents = (
   experience: CreateExperienceInput,
   eventsUid: Record<string, string>,
 ): CreateExperienceInput => {
+  log.debug('Starting event lookup for experience');
+  log.debug(`Available event mappings: ${Object.keys(eventsUid)?.length}`);
+  
   // Update events uid in experience metrics
   if (experience?.metrics?.length) {
+    log.debug(`Processing ${experience.metrics.length} experience metrics`);
+    
     for (let metricIndex = experience?.metrics?.length - 1; metricIndex >= 0; metricIndex--) {
       const metric: ExpMetric = experience?.metrics[metricIndex];
       const eventUid = metric.event;
+      
+      log.debug(`Processing metric ${metricIndex + 1}/${experience.metrics.length} with event: ${eventUid}`);
+      
       if (eventsUid.hasOwnProperty(eventUid) && eventsUid[eventUid]) {
-        experience.metrics[metricIndex].event = eventsUid[eventUid];
+        const newEventUid = eventsUid[eventUid];
+        log.debug(`Mapping event: ${eventUid} -> ${newEventUid}`);
+        experience.metrics[metricIndex].event = newEventUid;
       } else {
+        log.warn(`Event not found in mapping: ${eventUid}. Removing metric.`);
         experience?.metrics.splice(metricIndex, 1);
       }
     }
+    
+    log.debug(`Final metrics count: ${experience.metrics.length}`);
+  } else {
+    log.debug('No metrics found in experience');
   }
+  
+  log.debug('Event lookup completed for experience');
   return experience;
 };

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

@@ -1,5 +1,5 @@
 import { AdapterHelper } from './adapter-helper';
-import { HttpClient, authenticationHandler } from '@contentstack/cli-utilities';
+import { HttpClient, authenticationHandler, log } from '@contentstack/cli-utilities';
 
 import {
   ProjectStruct,
@@ -23,35 +23,51 @@ import {
   VariantGroupStruct,
   VariantGroup,
   CreateExperienceVersionInput,
+  ExportConfig
 } from '../types';
 import { formatErrors } from './error-helper';
 
 export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> implements Personalization<T> {
+  public exportConfig?: ExportConfig; // Add exportConfig property to access context
+
   constructor(options: APIConfig) {
     super(options);
+    log.debug('PersonalizationAdapter initialized', this.exportConfig?.context);
   }
 
   async init(): Promise<void> {
+    log.debug('Initializing personalization adapter...', this.exportConfig?.context );
     await authenticationHandler.getAuthDetails();
     const token = authenticationHandler.accessToken;
+    log.debug(`Authentication type: ${authenticationHandler.isOauthEnabled ? 'OAuth' : 'Token'}`, this.exportConfig?.context );
+    
     if (authenticationHandler.isOauthEnabled) {
+      log.debug('Setting OAuth authorization header', this.exportConfig?.context );
       this.apiClient.headers({ authorization: token });
       if (this.adapterConfig.cmaConfig) {
+        log.debug('Setting OAuth authorization header for CMA client', this.exportConfig?.context );
         this.cmaAPIClient?.headers({ authorization: token });
       }
     } else {
+      log.debug('Setting authtoken header', this.exportConfig?.context );
       this.apiClient.headers({ authtoken: token });
       if (this.adapterConfig.cmaConfig) {
+        log.debug('Setting authtoken header for CMA client', this.exportConfig?.context );
         this.cmaAPIClient?.headers({ authtoken: token });
       }
     }
+    log.debug('Personalization adapter initialization completed', this.exportConfig?.context );
   }
 
   async projects(options: GetProjectsParams): Promise<ProjectStruct[]> {
+    log.debug(`Fetching projects for stack API key: ${options.connectedStackApiKey}`, this.exportConfig?.context );
     await this.init();
     const getProjectEndPoint = `/projects?connectedStackApiKey=${options.connectedStackApiKey}`;
+    log.debug(`Making API call to: ${getProjectEndPoint}`, this.exportConfig?.context );
     const data = await this.apiClient.get(getProjectEndPoint);
-    return (await this.handleVariantAPIRes(data)) as ProjectStruct[];
+    const result = (await this.handleVariantAPIRes(data)) as ProjectStruct[];
+    log.debug(`Fetched ${result?.length || 0} projects`, this.exportConfig?.context );
+    return result;
   }
 
   /**
@@ -65,8 +81,11 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
    * `ProjectStruct` object or `void`.
    */
   async createProject(project: CreateProjectInput): Promise<ProjectStruct> {
+    log.debug(`Creating project: ${project.name}`, this.exportConfig?.context );
     const data = await this.apiClient.post<ProjectStruct>('/projects', project);
-    return (await this.handleVariantAPIRes(data)) as ProjectStruct;
+    const result = (await this.handleVariantAPIRes(data)) as ProjectStruct;
+    log.debug(`Project created successfully: ${result.uid}`, this.exportConfig?.context );
+    return result;
   }
 
   /**
@@ -79,41 +98,56 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
    * `ProjectStruct`.
    */
   async createAttribute(attribute: CreateAttributeInput): Promise<AttributeStruct> {
+    log.debug(`Creating attribute: ${attribute.name}`, this.exportConfig?.context );
     const data = await this.apiClient.post<AttributeStruct>('/attributes', attribute);
-    return (await this.handleVariantAPIRes(data)) as AttributeStruct;
+    const result = (await this.handleVariantAPIRes(data)) as AttributeStruct;
+    log.debug(`Attribute created successfully: ${result.uid}`, this.exportConfig?.context );
+    return result;
   }
 
   async getExperiences(): Promise<ExperienceStruct[]> {
+    log.debug('Fetching experiences from personalization API', this.exportConfig?.context );
     const getExperiencesEndPoint = `/experiences`;
     const data = await this.apiClient.get(getExperiencesEndPoint);
-    return (await this.handleVariantAPIRes(data)) as ExperienceStruct[];
+    const result = (await this.handleVariantAPIRes(data)) as ExperienceStruct[];
+    log.debug(`Fetched ${result?.length || 0} experiences`, this.exportConfig?.context );
+    return result;
   }
 
   async getExperience(experienceUid: string): Promise<ExperienceStruct | void> {
+    log.debug(`Fetching experience: ${experienceUid}`, this.exportConfig?.context );
     const getExperiencesEndPoint = `/experiences/${experienceUid}`;
     if (this.apiClient.requestConfig?.().data) {
       delete this.apiClient.requestConfig?.().data; // explicitly prevent any accidental body
     }
     const data = await this.apiClient.get(getExperiencesEndPoint);
-    return (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+    const result = (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+    log.debug(`Experience fetched successfully: ${result?.uid}`, this.exportConfig?.context );
+    return result;
   }
 
   async getExperienceVersions(experienceUid: string): Promise<ExperienceStruct | void> {
+    log.debug(`Fetching versions for experience: ${experienceUid}`, this.exportConfig?.context );
     const getExperiencesVersionsEndPoint = `/experiences/${experienceUid}/versions`;
     if (this.apiClient.requestConfig?.().data) {
       delete this.apiClient.requestConfig?.().data; // explicitly prevent any accidental body
     }
     const data = await this.apiClient.get(getExperiencesVersionsEndPoint);
-    return (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+    const result = (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+    log.debug(`Experience versions fetched successfully for: ${experienceUid}`, this.exportConfig?.context );
+    return result;
   }
 
   async createExperienceVersion(
     experienceUid: string,
     input: CreateExperienceVersionInput,
   ): Promise<ExperienceStruct | void> {
+    log.debug(`Creating experience version for: ${experienceUid}`, this.exportConfig?.context );
     const createExperiencesVersionsEndPoint = `/experiences/${experienceUid}/versions`;
     const data = await this.apiClient.post(createExperiencesVersionsEndPoint, input);
-    return (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+    const result = (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+    log.debug(`Experience version created successfully for: ${experienceUid}`, this.exportConfig?.context );
+    return result;
   }
 
   async updateExperienceVersion(
@@ -121,51 +155,77 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
     versionId: string,
     input: CreateExperienceVersionInput,
   ): Promise<ExperienceStruct | void> {
+    log.debug(`Updating experience version: ${versionId} for experience: ${experienceUid}`, this.exportConfig?.context );
     // loop through input and remove shortId from variant
     if (input?.variants) {
       input.variants = input.variants.map(({ shortUid, ...rest }) => rest);
+      log.debug(`Processed ${input.variants.length} variants for update`, this.exportConfig?.context );
     }
     const updateExperiencesVersionsEndPoint = `/experiences/${experienceUid}/versions/${versionId}`;
     const data = await this.apiClient.put(updateExperiencesVersionsEndPoint, input);
-    return (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+    const result = (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+    log.debug(`Experience version updated successfully: ${versionId}`, this.exportConfig?.context );
+    return result;
   }
 
   async getVariantGroup(input: GetVariantGroupInput): Promise<VariantGroupStruct | void> {
+    log.debug(`Fetching variant group for experience: ${input.experienceUid}`, this.exportConfig?.context );
     if (this.cmaAPIClient) {
       const getVariantGroupEndPoint = `/variant_groups`;
       const data = await this.cmaAPIClient
         .queryParams({ experience_uid: input.experienceUid })
         .get(getVariantGroupEndPoint);
-      return (await this.handleVariantAPIRes(data)) as VariantGroupStruct;
+      const result = (await this.handleVariantAPIRes(data)) as VariantGroupStruct;
+      log.debug(`Variant group fetched successfully for experience: ${input.experienceUid}`, this.exportConfig?.context );
+      return result;
+    } else {
+      log.debug('CMA API client not available for variant group fetch', this.exportConfig?.context );
     }
   }
 
   async updateVariantGroup(input: VariantGroup): Promise<VariantGroup | void> {
+    log.debug(`Updating variant group: ${input.uid}`, this.exportConfig?.context );
     if (this.cmaAPIClient) {
       const updateVariantGroupEndPoint = `/variant_groups/${input.uid}`;
       const data = await this.cmaAPIClient.put(updateVariantGroupEndPoint, input);
-      return (await this.handleVariantAPIRes(data)) as VariantGroup;
+      const result = (await this.handleVariantAPIRes(data)) as VariantGroup;
+      log.debug(`Variant group updated successfully: ${input.uid}`, this.exportConfig?.context );
+      return result;
+    } else {
+      log.debug('CMA API client not available for variant group update', this.exportConfig?.context );
     }
   }
 
   async getEvents(): Promise<EventStruct[] | void> {
+    log.debug('Fetching events from personalization API', this.exportConfig?.context );
     const data = await this.apiClient.get<EventStruct>('/events');
-    return (await this.handleVariantAPIRes(data)) as EventStruct[];
+    const result = (await this.handleVariantAPIRes(data)) as EventStruct[];
+    log.debug(`Fetched ${result?.length || 0} events`, this.exportConfig?.context );
+    return result;
   }
 
   async createEvents(event: CreateEventInput): Promise<void | EventStruct> {
+    log.debug(`Creating event: ${event.key}`, this.exportConfig?.context );
     const data = await this.apiClient.post<EventStruct>('/events', event);
-    return (await this.handleVariantAPIRes(data)) as EventStruct;
+    const result = (await this.handleVariantAPIRes(data)) as EventStruct;
+    log.debug(`Event created successfully: ${result.uid}`, this.exportConfig?.context );
+    return result;
   }
 
   async getAudiences(): Promise<AudienceStruct[] | void> {
+    log.debug('Fetching audiences from personalization API', this.exportConfig?.context );
     const data = await this.apiClient.get<AudienceStruct>('/audiences');
-    return (await this.handleVariantAPIRes(data)) as AudienceStruct[];
+    const result = (await this.handleVariantAPIRes(data)) as AudienceStruct[];
+    log.debug(`Fetched ${result?.length || 0} audiences`, this.exportConfig?.context );
+    return result;
   }
 
   async getAttributes(): Promise<AttributeStruct[] | void> {
+    log.debug('Fetching attributes from personalization API', this.exportConfig?.context );
     const data = await this.apiClient.get<AttributeStruct>('/attributes');
-    return (await this.handleVariantAPIRes(data)) as AttributeStruct[];
+    const result = (await this.handleVariantAPIRes(data)) as AttributeStruct[];
+    log.debug(`Fetched ${result?.length || 0} attributes`, this.exportConfig?.context );
+    return result;
   }
 
   /**
@@ -177,8 +237,11 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
    * `AudienceStruct`.
    */
   async createAudience(audience: CreateAudienceInput): Promise<void | AudienceStruct> {
+    log.debug(`Creating audience: ${audience.name}`, this.exportConfig?.context );
     const data = await this.apiClient.post<AudienceStruct>('/audiences', audience);
-    return (await this.handleVariantAPIRes(data)) as AudienceStruct;
+    const result = (await this.handleVariantAPIRes(data)) as AudienceStruct;
+    log.debug(`Audience created successfully: ${result.uid}`, this.exportConfig?.context );
+    return result;
   }
 
   /**
@@ -190,8 +253,11 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
    * `ExperienceStruct`.
    */
   async createExperience(experience: CreateExperienceInput): Promise<void | ExperienceStruct> {
+    log.debug(`Creating experience: ${experience.name}`, this.exportConfig?.context );
     const data = await this.apiClient.post<ExperienceStruct>('/experiences', experience);
-    return (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+    const result = (await this.handleVariantAPIRes(data)) as ExperienceStruct;
+    log.debug(`Experience created successfully: ${result.uid}`, this.exportConfig?.context );
+    return result;
   }
 
   /**
@@ -203,9 +269,12 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
     experience: UpdateExperienceInput,
     experienceUid: string,
   ): Promise<void | CMSExperienceStruct> {
+    log.debug(`Updating content types in experience: ${experienceUid}`, this.exportConfig?.context );
     const updateCTInExpEndPoint = `/experiences/${experienceUid}/cms-integration/variant-group`;
     const data = await this.apiClient.post<CMSExperienceStruct>(updateCTInExpEndPoint, experience);
-    return (await this.handleVariantAPIRes(data)) as CMSExperienceStruct;
+    const result = (await this.handleVariantAPIRes(data)) as CMSExperienceStruct;
+    log.debug(`Content types updated successfully in experience: ${experienceUid}`, this.exportConfig?.context );
+    return result;
   }
 
   /**
@@ -214,9 +283,12 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
    * needed to fetch CT details related to experience.
    */
   async getCTsFromExperience(experienceUid: string): Promise<void | CMSExperienceStruct> {
+    log.debug(`Fetching content types from experience: ${experienceUid}`, this.exportConfig?.context );
     const getCTFromExpEndPoint = `/experiences/${experienceUid}/cms-integration/variant-group`;
     const data = await this.apiClient.get<CMSExperienceStruct>(getCTFromExpEndPoint);
-    return (await this.handleVariantAPIRes(data)) as CMSExperienceStruct;
+    const result = (await this.handleVariantAPIRes(data)) as CMSExperienceStruct;
+    log.debug(`Content types fetched successfully from experience: ${experienceUid}`, this.exportConfig?.context );
+    return result;
   }
 
   /**
@@ -227,17 +299,21 @@ export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> impl
    */
   async handleVariantAPIRes(res: APIResponse): Promise<VariantAPIRes> {
     const { status, data } = res;
+    log.debug(`API response status: ${status}`, this.exportConfig?.context );
 
     if (status >= 200 && status < 300) {
+      log.debug('API request successful', this.exportConfig?.context );
       return data;
     }
 
+    log.debug(`API request failed with status: ${status}`, this.exportConfig?.context );
     // Refresh the access token if it has expired
     await authenticationHandler.refreshAccessToken(res);
 
     const errorMsg = data?.errors
       ? formatErrors(data.errors)
       : data?.error || data?.error_message || data?.message || data;
+    log.debug(`API error: ${errorMsg}`, this.exportConfig?.context );
     throw errorMsg;
   }
 }