@contentstack/cli-variants 0.0.1-alpha

package/src/utils/adapter-helper.ts

@@ -0,0 +1,79 @@
+import pick from 'lodash/pick';
+import { HttpClient, HttpClientOptions, HttpRequestConfig } from '@contentstack/cli-utilities';
+
+import messages, { $t } from '../messages';
+import { APIConfig, AdapterHelperInterface } from '../types';
+
+export class AdapterHelper<C, ApiClient> implements AdapterHelperInterface<C, ApiClient> {
+  public readonly config: C;
+  public readonly $t: typeof $t;
+  public readonly apiClient: ApiClient;
+  public readonly cmaAPIClient?: ApiClient;
+  public readonly messages: typeof messages;
+
+  constructor(public readonly adapterConfig: APIConfig, options?: HttpClientOptions) {
+    this.$t = $t;
+    this.messages = messages;
+    this.config = adapterConfig.config as C;
+    delete this.adapterConfig.config;
+    const pickConfig: (keyof HttpRequestConfig)[] = [
+      'url',
+      'auth',
+      'method',
+      'baseURL',
+      'headers',
+      'adapter',
+      'httpAgent',
+      'httpsAgent',
+      'responseType',
+    ];
+    this.apiClient = new HttpClient(pick(adapterConfig, pickConfig), options) as ApiClient;
+    if (adapterConfig.cmaConfig) {
+      this.cmaAPIClient = new HttpClient(pick(adapterConfig.cmaConfig, pickConfig), options) as ApiClient;
+    }
+  }
+
+  /**
+   * The function constructs a query string from a given object by encoding its key-value pairs.
+   * @param query - It looks like you have a function `constructQuery` that takes a query object as a
+   * parameter. The function loops through the keys in the query object and constructs a query string
+   * based on the key-value pairs.
+   * @returns The `constructQuery` function returns a string that represents the query parameters
+   * constructed from the input `query` object. If the `query` object is empty (has no keys), the
+   * function does not return anything (void).
+   */
+  constructQuery(query: Record<string, any>): string | void {
+    if (Object.keys(query).length) {
+      let queryParam = '';
+
+      for (const key in query) {
+        if (Object.prototype.hasOwnProperty.call(query, key)) {
+          const element = query[key];
+
+          switch (typeof element) {
+            case 'boolean':
+              queryParam = queryParam.concat(key);
+              break;
+
+            default:
+              queryParam = queryParam.concat(`&${key}=${encodeURIComponent(element)}`);
+              break;
+          }
+        }
+      }
+
+      return queryParam;
+    }
+  }
+
+  /**
+   * The `delay` function in TypeScript returns a Promise that resolves after a specified number of
+   * milliseconds.
+   * @param {number} ms - The `ms` parameter represents the number of milliseconds for which the delay
+   * should occur before the `Promise` is resolved.
+   * @returns A Promise that resolves after the specified delay in milliseconds.
+   */
+  delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms <= 0 ? 0 : ms));
+  }
+}

package/src/utils/attributes-helper.ts

@@ -0,0 +1,31 @@
+/**
+ * function to either modify the UID or eliminate it if the attribute is not created in the target project
+ * @param attributeRules 
+ * @param attributesUid - {attributesUid} attributes mapper data in format {<old-uid>: <new-uid>}
+ * @returns 
+ */
+export const lookUpAttributes = (attributeRules: Record<string, any>[], attributesUid: Record<string, string>) => {
+  for (let index =0; index< attributeRules?.length; index++) {
+    const rule = attributeRules[index];
+
+    if (rule['__type'] === 'Rule') {
+      // 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') {
+        if (attributeRef && attributesUid.hasOwnProperty(attributeRef) && attributesUid[attributeRef]) {
+          rule.attribute.ref = attributesUid[attributeRef];
+        } else {
+          // Remove the rule if the attribute reference is not found
+          attributeRules.splice(index, 1);
+          --index;
+        }
+      }
+    } else if (rule['__type'] === 'RuleCombination' && Array.isArray(rule.rules)) {
+      // Recursively look up attributes in nested rule combinations
+      lookUpAttributes(rule.rules, attributesUid);
+    }
+  }
+  return attributeRules;
+};

package/src/utils/audiences-helper.ts

@@ -0,0 +1,50 @@
+import { CreateExperienceInput } from '../types';
+
+/**
+ * function for substituting an old audience UID with a new one or deleting the audience information if it does not exist
+ * @param audiences - {audiences} list of audience
+ * @param audiencesUid - {audiencesUid} audiences mapper data in format {<old-uid>: <new-uid>}
+ */
+function updateAudiences(audiences: string[], audiencesUid: Record<string, string>) {
+  for (let audienceIndex = audiences.length - 1; audienceIndex >= 0; audienceIndex--) {
+    const audienceUid = audiences[audienceIndex];
+    if (audiencesUid.hasOwnProperty(audienceUid) && audiencesUid[audienceUid]) {
+      audiences[audienceIndex] = audiencesUid[audienceUid];
+    } else {
+      audiences.splice(audienceIndex, 1);
+    }
+  }
+}
+
+/**
+ * function to either modify the UID or eliminate it if the audience is not created in the target project
+ * @param experience - experience object
+ * @param audiencesUid - {audiencesUid} audiences mapper data in format {<old-uid>: <new-uid>}
+ * @returns
+ */
+export const lookUpAudiences = (
+  experience: CreateExperienceInput,
+  audiencesUid: Record<string, string>,
+): CreateExperienceInput => {
+  // Update experience variations
+  if (experience?.variations?.length) {
+    for (let index = experience.variations.length - 1; index >= 0; index--) {
+      const expVariations = experience.variations[index];
+      if (expVariations['__type'] === 'AudienceBasedVariation' && expVariations?.audiences?.length) {
+        updateAudiences(expVariations.audiences, audiencesUid);
+        if (!expVariations.audiences.length) {
+          experience.variations.splice(index, 1);
+        }
+      }
+    }
+  }
+
+  // Update targeting audiences
+  if (experience?.targeting?.hasOwnProperty('audience') && experience?.targeting?.audience?.audiences?.length) {
+    updateAudiences(experience.targeting.audience.audiences, audiencesUid);
+    if (!experience.targeting.audience.audiences.length) {
+      experience.targeting = {};
+    }
+  }
+  return experience;
+};

package/src/utils/error-helper.ts

@@ -0,0 +1,26 @@
+/**
+ * Formats the errors into a single string.
+ * @param errors - The errors to be formatted.
+ * @returns The formatted errors as a string.
+ */
+export function formatErrors(errors: any): string {
+  const errorMessages: string[] = [];
+
+  for (const errorKey in errors) {
+    const errorValue = errors[errorKey];
+    if (Array.isArray(errorValue)) {
+      errorMessages.push(...errorValue.map((error: any) => formatError(error)));
+    } else {
+      errorMessages.push(formatError(errorValue));
+    }
+  }
+
+  return errorMessages.join(' ');
+}
+
+function formatError(error: any): string {
+  if (typeof error === 'object') {
+    return Object.values(error).join(' ');
+  }
+  return String(error);
+}

package/src/utils/events-helper.ts

@@ -0,0 +1,26 @@
+import { CreateExperienceInput, ExpMetric } from '../types';
+
+/**
+ * function to either modify the UID or eliminate it if the event is not created in the target project
+ * @param experience - experience object 
+ * @param eventsUid - {eventsUid} events mapper data in format {<old-uid>: <new-uid>}
+ * @returns
+ */
+export const lookUpEvents = (
+  experience: CreateExperienceInput,
+  eventsUid: Record<string, string>,
+): CreateExperienceInput => {
+  // Update events uid in experience metrics
+  if (experience?.metrics?.length) {
+    for (let metricIndex = experience?.metrics?.length - 1; metricIndex >= 0; metricIndex--) {
+      const metric: ExpMetric = experience?.metrics[metricIndex];
+      const eventUid = metric.event;
+      if (eventsUid.hasOwnProperty(eventUid) && eventsUid[eventUid]) {
+        experience.metrics[metricIndex].event = eventsUid[eventUid];
+      } else {
+        experience?.metrics.splice(metricIndex, 1);
+      }
+    }
+  }
+  return experience;
+};

package/src/utils/helper.ts

@@ -0,0 +1,34 @@
+import { FsUtility, cliux } from '@contentstack/cli-utilities';
+
+export const formatError = function (error: any) {
+  try {
+    if (typeof error === 'string') {
+      error = JSON.parse(error);
+    } else {
+      error = JSON.parse(error.message);
+    }
+  } catch (e) {}
+  let message = error.errorMessage || error.error_message || error.message || error;
+  if (error.errors && Object.keys(error.errors).length > 0) {
+    Object.keys(error.errors).forEach((e) => {
+      let entity = e;
+      if (e === 'authorization') entity = 'Management Token';
+      if (e === 'api_key') entity = 'Stack API key';
+      if (e === 'uid') entity = 'Content Type';
+      if (e === 'access_token') entity = 'Delivery Token';
+      message += ' ' + [entity, error.errors[e]].join(' ');
+    });
+  }
+  return message;
+};
+
+export const fsUtil = new FsUtility();
+
+export const askProjectName = async (defaultValue: unknown): Promise<string> => {
+  return await cliux.inquire({
+    type: 'input',
+    name: 'name',
+    default: defaultValue,
+    message: 'Enter the project name:',
+  });
+};

package/src/utils/index.ts

@@ -0,0 +1,9 @@
+export * from './adapter-helper';
+export * from './variant-api-adapter';
+export * from './personalization-api-adapter';
+export * from './logger';
+export * from './helper';
+export * from './attributes-helper';
+export * from './audiences-helper';
+export * from './events-helper';
+export * from './error-helper';

package/src/utils/logger.ts

@@ -0,0 +1,160 @@
+import * as winston from 'winston';
+import * as path from 'path';
+import mkdirp from 'mkdirp';
+import { sanitizePath } from '@contentstack/cli-utilities';
+import { ExportConfig, ImportConfig } from '../types';
+
+const slice = Array.prototype.slice;
+
+const ansiRegexPattern = [
+  '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+  '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))',
+].join('|');
+
+function returnString(args: unknown[]) {
+  let returnStr = '';
+  if (args && args.length) {
+    returnStr = args
+      .map(function (item) {
+        if (item && typeof item === 'object') {
+          try {
+            return JSON.stringify(item).replace(/authtoken\":\d"blt................/g, 'authtoken":"blt....');
+          } catch (error) {}
+          return item;
+        }
+        return item;
+      })
+      .join('  ')
+      .trim();
+  }
+  returnStr = returnStr.replace(new RegExp(ansiRegexPattern, 'g'), '').trim();
+  return returnStr;
+}
+const myCustomLevels = {
+  levels: {
+    warn: 1,
+    info: 2,
+    debug: 3,
+  },
+  colors: {
+    //colors aren't being used anywhere as of now, we're using chalk to add colors while logging
+    info: 'blue',
+    debug: 'green',
+    warn: 'yellow',
+    error: 'red',
+  },
+};
+
+let logger: winston.Logger;
+let errorLogger: winston.Logger;
+
+let successTransport;
+let errorTransport;
+
+function init(_logPath: string) {
+  if (!logger || !errorLogger) {
+    const logsDir = path.resolve(sanitizePath(_logPath), 'logs', 'export');
+    // Create dir if doesn't already exist
+    mkdirp.sync(logsDir);
+
+    successTransport = {
+      filename: path.join(sanitizePath(logsDir), 'success.log'),
+      maxFiles: 20,
+      maxsize: 1000000,
+      tailable: true,
+      level: 'info',
+    };
+
+    errorTransport = {
+      filename: path.join(sanitizePath(logsDir), 'error.log'),
+      maxFiles: 20,
+      maxsize: 1000000,
+      tailable: true,
+      level: 'error',
+    };
+
+    logger = winston.createLogger({
+      transports: [
+        new winston.transports.File(successTransport),
+        new winston.transports.Console({ format: winston.format.simple() }),
+      ],
+      levels: myCustomLevels.levels,
+    });
+
+    errorLogger = winston.createLogger({
+      transports: [
+        new winston.transports.File(errorTransport),
+        new winston.transports.Console({
+          level: 'error',
+          format: winston.format.combine(
+            winston.format.colorize({ all: true, colors: { error: 'red' } }),
+            winston.format.simple(),
+          ),
+        }),
+      ],
+      levels: { error: 0 },
+    });
+  }
+
+  return {
+    log: function (message: any) {
+      const args = slice.call(arguments);
+      const logString = returnString(args);
+      if (logString) {
+        logger.log('info', logString);
+      }
+    },
+    warn: function () {
+      const args = slice.call(arguments);
+      const logString = returnString(args);
+      if (logString) {
+        logger.log('warn', logString);
+      }
+    },
+    error: function (message: any) {
+      const args = slice.call(arguments);
+      const logString = returnString(args);
+      if (logString) {
+        errorLogger.log('error', logString);
+      }
+    },
+    debug: function () {
+      const args = slice.call(arguments);
+      const logString = returnString(args);
+      if (logString) {
+        logger.log('debug', logString);
+      }
+    },
+  };
+}
+
+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
+  if (type !== 'error') {
+    // removed type argument from init method
+    init(logsPath).log(message);
+  } else {
+    init(logsPath).error(message);
+  }
+};
+
+export const unlinkFileLogger = () => {
+  if (logger) {
+    const transports = logger.transports;
+    transports.forEach((transport: any) => {
+      if (transport.name === 'file') {
+        logger.remove(transport);
+      }
+    });
+  }
+
+  if (errorLogger) {
+    const transports = errorLogger.transports;
+    transports.forEach((transport: any) => {
+      if (transport.name === 'file') {
+        errorLogger.remove(transport);
+      }
+    });
+  }
+};

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

@@ -0,0 +1,188 @@
+import { AdapterHelper } from './adapter-helper';
+import { HttpClient } from '@contentstack/cli-utilities';
+
+import {
+  ProjectStruct,
+  Personalization,
+  GetProjectsParams,
+  CreateProjectInput,
+  CreateAttributeInput,
+  APIConfig,
+  GetVariantGroupInput,
+  EventStruct,
+  AudienceStruct,
+  AttributeStruct,
+  CreateAudienceInput,
+  CreateEventInput,
+  CreateExperienceInput,
+  ExperienceStruct,
+  UpdateExperienceInput,
+  CMSExperienceStruct,
+  VariantAPIRes,
+  APIResponse,
+  VariantGroupStruct,
+  VariantGroup,
+} from '../types';
+import { formatErrors } from './error-helper';
+
+export class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> implements Personalization<T> {
+  constructor(options: APIConfig) {
+    super(options);
+  }
+
+  async projects(options: GetProjectsParams): Promise<ProjectStruct[]> {
+    const getProjectEndPoint = `/projects?connectedStackApiKey=${options.connectedStackApiKey}`;
+    const data = await this.apiClient.get(getProjectEndPoint);
+    return this.handleVariantAPIRes(data) as ProjectStruct[];
+  }
+
+  /**
+   * This TypeScript function creates a project by making an asynchronous API call to retrieve project
+   * data.
+   * @param {CreateProjectInput} input - The `input` parameter in the `createProject` function likely
+   * represents the data needed to create a new project. It could include details such as the project
+   * name, description, owner, deadline, or any other relevant information required to set up a new
+   * project.
+   * @returns The `createProject` function is returning a Promise that resolves to either a
+   * `ProjectStruct` object or `void`.
+   */
+  async createProject(project: CreateProjectInput): Promise<ProjectStruct> {
+    const data = await this.apiClient.post<ProjectStruct>('/projects', project);
+    return this.handleVariantAPIRes(data) as ProjectStruct;
+  }
+
+  /**
+   * The function `createAttribute` asynchronously retrieves attribute data from an API endpoint.
+   * @param {CreateAttributeInput} input - The `input` parameter in the `createAttribute` function is
+   * of type `CreateAttributeInput`. This parameter likely contains the necessary data or information
+   * needed to create a new attribute.
+   * @returns The `createAttribute` function is returning the data obtained from a GET request to the
+   * `/attributes` endpoint using the `apiClient` with the input provided. The data returned is of type
+   * `ProjectStruct`.
+   */
+  async createAttribute(attribute: CreateAttributeInput): Promise<AttributeStruct> {
+    const data = await this.apiClient.post<AttributeStruct>('/attributes', attribute);
+    return 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[];
+  }
+
+  async getExperience(experienceUid: string): Promise<ExperienceStruct | void> {
+    const getExperiencesEndPoint = `/experiences/${experienceUid}`;
+    const data = await this.apiClient.get(getExperiencesEndPoint);
+    return this.handleVariantAPIRes(data) as ExperienceStruct;
+  }
+
+  async getVariantGroup(input: GetVariantGroupInput): Promise<VariantGroupStruct | void> {
+    if (this.cmaAPIClient) {
+      const getVariantGroupEndPoint = `/variant_groups`;
+      const data = await this.cmaAPIClient
+        .queryParams({ experience_uid: input.experienceUid })
+        .get(getVariantGroupEndPoint);
+      return this.handleVariantAPIRes(data) as VariantGroupStruct;
+    }
+  }
+
+  async updateVariantGroup(input: VariantGroup): Promise<VariantGroup | void> {
+    if (this.cmaAPIClient) {
+      const updateVariantGroupEndPoint = `/variant_groups/${input.uid}`;
+      const data = await this.cmaAPIClient.put(updateVariantGroupEndPoint, input);
+      return this.handleVariantAPIRes(data) as VariantGroup;
+    }
+  }
+
+  async getEvents(): Promise<EventStruct[] | void> {
+    const data = await this.apiClient.get<EventStruct>('/events');
+    return 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;
+  }
+
+  async getAudiences(): Promise<AudienceStruct[] | void> {
+    const data = await this.apiClient.get<AudienceStruct>('/audiences');
+    return this.handleVariantAPIRes(data) as AudienceStruct[];
+  }
+
+  async getAttributes(): Promise<AttributeStruct[] | void> {
+    const data = await this.apiClient.get<AttributeStruct>('/attributes');
+    return this.handleVariantAPIRes(data) as AttributeStruct[];
+  }
+
+  /**
+   * @param {CreateAudienceInput} audience - The `audience` parameter in the `createAudience` function is
+   * of type `CreateAudienceInput`. This parameter likely contains the necessary data or information
+   * needed to create a new audience.
+   * @returns The `createAudience` function is returning the data obtained from a GET request to the
+   * `/audiences` endpoint using the `apiClient` with the input provided. The data returned is of type
+   * `AudienceStruct`.
+   */
+  async createAudience(audience: CreateAudienceInput): Promise<void | AudienceStruct> {
+    const data = await this.apiClient.post<AudienceStruct>('/audiences', audience);
+    return this.handleVariantAPIRes(data) as AudienceStruct;
+  }
+
+  /**
+   * @param {CreateExperienceInput} experience - The `experience` parameter in the `createExperience` function is
+   * of type `CreateExperienceInput`. This parameter likely contains the necessary data or information
+   * needed to create a new audience.
+   * @returns The `createExperience` function is returning the data obtained from a GET request to the
+   * `/experiences` endpoint using the `apiClient` with the input provided. The data returned is of type
+   * `ExperienceStruct`.
+   */
+  async createExperience(experience: CreateExperienceInput): Promise<void | ExperienceStruct> {
+    const data = await this.apiClient.post<ExperienceStruct>('/experiences', experience);
+    return this.handleVariantAPIRes(data) as ExperienceStruct;
+  }
+
+  /**
+   * @param {UpdateExperienceInput} experience - The `experience` parameter in the `updateCTsInExperience` function is
+   * of type `UpdateExperienceInput`. This parameter likely contains the necessary data or information
+   * needed to attach CT in new created experience.
+   */
+  async updateCTsInExperience(
+    experience: UpdateExperienceInput,
+    experienceUid: string,
+  ): 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;
+  }
+
+  /**
+   * @param {UpdateExperienceInput} experienceUid - The `experienceUid` parameter in the `getCTsFromExperience` function is
+   * of type `string`. This parameter likely contains the necessary data or information
+   * needed to fetch CT details related to experience.
+   */
+  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;
+  }
+
+  /**
+   * Handles the API response for variant requests.
+   * @param res - The API response object.
+   * @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 {
+    const { status, data } = res;
+
+    if (status >= 200 && status < 300) {
+      return data;
+    }
+
+    const errorMsg = data?.errors
+      ? formatErrors(data.errors)
+      : data?.error_message || data?.message || 'Something went wrong while processing variant entries request!';
+
+    throw errorMsg;
+  }
+}