@contentstack/cli-variants 0.0.1-alpha

package/src/export/events.ts

@@ -0,0 +1,57 @@
+import omit from 'lodash/omit';
+import { resolve as pResolve } from 'node:path';
+
+import { formatError, fsUtil, PersonalizationAdapter, log } from '../utils';
+import { PersonalizationConfig, ExportConfig, EventStruct, EventsConfig } from '../types';
+
+export default class ExportEvents extends PersonalizationAdapter<ExportConfig> {
+  private eventsConfig: EventsConfig;
+  private eventsFolderPath: string;
+  private events: Record<string, unknown>[];
+  public personalizationConfig: PersonalizationConfig;
+
+  constructor(readonly exportConfig: ExportConfig) {
+    super({
+      config: exportConfig,
+      baseURL: exportConfig.modules.personalization.baseURL[exportConfig.region.name],
+      headers: { authtoken: exportConfig.auth_token, 'X-Project-Uid': exportConfig.project_id },
+    });
+    this.personalizationConfig = exportConfig.modules.personalization;
+    this.eventsConfig = exportConfig.modules.events;
+    this.eventsFolderPath = pResolve(
+      exportConfig.data,
+      exportConfig.branchName || '',
+      this.personalizationConfig.dirName,
+      this.eventsConfig.dirName,
+    );
+    this.events = [];
+  }
+
+  async start() {
+    try {
+      log(this.exportConfig, 'Starting events export', 'info');
+      await fsUtil.makeDirectory(this.eventsFolderPath);
+      this.events = (await this.getEvents()) as EventStruct[];
+
+      if (!this.events?.length) {
+        log(this.exportConfig, 'No Events found with the given project!', 'info');
+        return;
+      } else {
+        this.sanitizeAttribs();
+        fsUtil.writeFile(pResolve(this.eventsFolderPath, this.eventsConfig.fileName), this.events);
+        log(this.exportConfig, 'All the events have been exported successfully!', 'success');
+        return;
+      }
+    } catch (error) {
+      log(this.exportConfig, `Failed to export events!`, 'error');
+      log(this.config, error, 'error');
+    }
+  }
+
+  /**
+   * function to remove invalid keys from event object
+   */
+  sanitizeAttribs() {
+    this.events = this.events?.map((event) => omit(event, this.eventsConfig.invalidKeys)) || [];
+  }
+}

package/src/export/experiences.ts

@@ -0,0 +1,80 @@
+import * as path from 'path';
+import { sanitizePath } from '@contentstack/cli-utilities';
+import { PersonalizationConfig, ExportConfig, ExperienceStruct } from '../types';
+import { formatError, fsUtil, log, PersonalizationAdapter } from '../utils';
+
+export default class ExportExperiences extends PersonalizationAdapter<ExportConfig> {
+  private experiencesFolderPath: string;
+  public exportConfig: ExportConfig;
+  public personalizationConfig: PersonalizationConfig;
+  constructor(exportConfig: ExportConfig) {
+    super({
+      config: exportConfig,
+      baseURL: exportConfig.modules.personalization.baseURL[exportConfig.region.name],
+      headers: { authtoken: exportConfig.auth_token, 'X-Project-Uid': exportConfig.project_id },
+      cmaConfig: {
+        baseURL: exportConfig.region.cma + `/v3`,
+        headers: { authtoken: exportConfig.auth_token, api_key: exportConfig.apiKey },
+      },
+    });
+    this.exportConfig = exportConfig;
+    this.personalizationConfig = exportConfig.modules.personalization;
+    this.experiencesFolderPath = path.resolve(
+      sanitizePath(exportConfig.data),
+      sanitizePath(exportConfig.branchName || ''),
+      sanitizePath(this.personalizationConfig.dirName),
+      'experiences',
+    );
+  }
+
+  async start() {
+    try {
+      // get all experiences
+      // loop through experiences and get content types attached to it
+      // write experiences in to a file
+      log(this.exportConfig, 'Starting experiences export', 'info');
+      await fsUtil.makeDirectory(this.experiencesFolderPath);
+      const experiences: Array<ExperienceStruct> = (await this.getExperiences()) || [];
+      if (!experiences || experiences?.length < 1) {
+        log(this.exportConfig, 'No Experiences found with the give project', 'info');
+        return;
+      }
+      fsUtil.writeFile(path.resolve(sanitizePath(this.experiencesFolderPath), 'experiences.json'), experiences);
+
+      const experienceToVariantsStrList: Array<string> = [];
+      const experienceToContentTypesMap: Record<string, string[]> = {};
+      for (let experience of experiences) {
+        // create id mapper for experience to variants
+        let variants = experience?._cms?.variants ?? {};
+        Object.keys(variants).forEach((variantShortId: string) => {
+          const experienceToVariantsStr = `${experience.uid}-${variantShortId}-${variants[variantShortId]}`;
+          experienceToVariantsStrList.push(experienceToVariantsStr);
+        });
+
+        try {
+          // fetch content of experience
+          const { variant_groups: [variantGroup] = [] } =
+            (await this.getVariantGroup({ experienceUid: experience.uid })) || {};
+          if (variantGroup?.content_types?.length) {
+            experienceToContentTypesMap[experience.uid] = variantGroup.content_types;
+          }
+        } catch (error) {
+          log(this.exportConfig, `Failed to fetch content types of experience ${experience.name}`, 'error');
+        }
+      }
+      fsUtil.writeFile(
+        path.resolve(sanitizePath(this.experiencesFolderPath), 'experiences-variants-ids.json'),
+        experienceToVariantsStrList,
+      );
+
+      fsUtil.writeFile(
+        path.resolve(sanitizePath(this.experiencesFolderPath), 'experiences-content-types.json'),
+        experienceToContentTypesMap,
+      );
+      log(this.exportConfig, 'All the experiences have been exported successfully!', 'success');
+    } catch (error) {
+      log(this.exportConfig, `Failed to export experiences!`, 'error');
+      log(this.config, error, 'error');
+    }
+  }
+}

package/src/export/index.ts

@@ -0,0 +1,11 @@
+export { default as ExportProjects } from './projects';
+export { default as ExportExperiences } from './experiences';
+import VariantEntries from './variant-entries';
+export { default as ExportEvents } from './events';
+export { default as ExportAudiences } from './audiences';
+export { default as ExportAttributes } from './attributes';
+
+// NOTE Acting as namespace to avoid the same class name conflicts in other modules
+export const Export = {
+  VariantEntries,
+};

package/src/export/projects.ts

@@ -0,0 +1,45 @@
+import * as path from 'path';
+import { sanitizePath } from '@contentstack/cli-utilities';
+import { ExportConfig, PersonalizationConfig } 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;
+  constructor(exportConfig: ExportConfig) {
+    super({
+      config: exportConfig,
+      baseURL: exportConfig.modules.personalization.baseURL[exportConfig.region.name],
+      headers: { authtoken: exportConfig.auth_token, organization_uid: exportConfig.org_uid },
+    });
+    this.exportConfig = exportConfig;
+    this.personalizationConfig = exportConfig.modules.personalization;
+    this.projectFolderPath = path.resolve(
+      sanitizePath(exportConfig.data),
+      sanitizePath(exportConfig.branchName || ''),
+      sanitizePath(this.personalizationConfig.dirName),
+      'projects',
+    );
+  }
+
+  async start() {
+    try {
+      log(this.exportConfig, 'Starting projects export', 'info');
+      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');
+        this.exportConfig.personalizationEnabled = false;
+        return;
+      }
+      this.exportConfig.personalizationEnabled = true;
+      this.exportConfig.project_id = project[0]?.uid;
+      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');
+      throw error;
+    }
+  }
+}

package/src/export/variant-entries.ts

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync } from 'fs';
+import { join, resolve } from 'path';
+import { FsUtility, sanitizePath } from '@contentstack/cli-utilities';
+
+import { APIConfig, AdapterType, ExportConfig, LogType } from '../types';
+import VariantAdapter, { VariantHttpClient } from '../utils/variant-api-adapter';
+import { fsUtil, log } from '../utils';
+
+export default class VariantEntries extends VariantAdapter<VariantHttpClient<ExportConfig>> {
+  public entriesDirPath: string;
+  public variantEntryBasePath!: string;
+
+  constructor(readonly config: ExportConfig) {
+    const conf: APIConfig & AdapterType<VariantHttpClient<ExportConfig>, APIConfig> = {
+      config,
+      httpClient: true,
+      baseURL: config.host,
+      Adapter: VariantHttpClient<ExportConfig>,
+      headers: {
+        api_key: config.apiKey,
+        branch: config.branchName,
+        authtoken: config.auth_token,
+        organization_uid: config.org_uid,
+        'X-Project-Uid': config.project_id,
+      },
+    };
+    super(Object.assign(config, conf));
+    this.entriesDirPath = resolve(sanitizePath(config.data), sanitizePath(config.branchName || ''), sanitizePath(config.modules.entries.dirName));
+  }
+
+  /**
+   * This function exports variant entries for a specific content type and locale.
+   * @param options - The `exportVariantEntry` function takes in an `options` object with the following
+   * properties:
+   */
+  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;
+
+    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));
+      const variantEntriesFs = new FsUtility({
+        isArray: true,
+        keepMetadata: false,
+        moduleName: 'variant-entry',
+        basePath: variantEntryBasePath,
+        indexFileName: variantEntry.fileName,
+        chunkFileSize: variantEntry.chunkFileSize || 1,
+        createDirIfNotExist: false,
+      });
+
+      const callback = (variantEntries: Record<string, any>[]) => {
+        if (variantEntries?.length) {
+          if (!existsSync(variantEntryBasePath)) {
+            mkdirSync(variantEntryBasePath, { recursive: true });
+          }
+          variantEntriesFs.writeIntoFile(variantEntries);
+        }
+      };
+
+      try {
+        await this.variantInstance.variantEntries({
+          callback,
+          getAllData: true,
+          content_type_uid,
+          entry_uid: entry.uid,
+          locale,
+        });
+        if (existsSync(variantEntryBasePath)) {
+          variantEntriesFs.completeFile(true);
+          log(
+            this.config,
+            `Exported variant entries of type '${entry.title} (${entry.uid})' locale '${locale}'`,
+            'info',
+          );
+        }
+      } catch (error) {
+        log(
+          this.config,
+          `Error exporting variant entries of type '${entry.title} (${entry.uid})' locale '${locale}'`,
+          'error',
+        );
+        log(this.config, error, 'error');
+      }
+    }
+  }
+}

package/src/import/attribute.ts

@@ -0,0 +1,60 @@
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import { sanitizePath } from '@contentstack/cli-utilities';
+import { PersonalizationAdapter, fsUtil } from '../utils';
+import { APIConfig, AttributeStruct, ImportConfig, LogType } from '../types';
+
+export default class Attribute extends PersonalizationAdapter<ImportConfig> {
+  private mapperDirPath: string;
+  private attrMapperDirPath: string;
+  private attributesUidMapperPath: string;
+  private attributesUidMapper: Record<string, unknown>;
+  private personalizationConfig: ImportConfig['modules']['personalization'];
+  private attributeConfig: ImportConfig['modules']['personalization']['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 },
+    };
+    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.attrMapperDirPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.attributeConfig.dirName));
+    this.attributesUidMapperPath = resolve(sanitizePath(this.attrMapperDirPath), 'uid-mapping.json');
+    this.attributesUidMapper = {};
+  }
+
+  /**
+   * The function asynchronously imports attributes from a JSON file and creates them in the system.
+   */
+  async import() {
+    this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Attributes' }), 'info');
+
+    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));
+
+    if (existsSync(attributesPath)) {
+      try {
+        const attributes = fsUtil.readFile(attributesPath, true) as AttributeStruct[];
+
+        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 ?? '';
+        }
+
+        fsUtil.writeFile(this.attributesUidMapperPath, this.attributesUidMapper);
+        this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Attributes' }), 'info');
+      } catch (error) {
+        this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Attributes' }), 'error');
+        this.log(this.config, error, 'error');
+      }
+    }
+  }
+}

package/src/import/audiences.ts

@@ -0,0 +1,69 @@
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import { sanitizePath } from '@contentstack/cli-utilities';
+import { APIConfig, AudienceStruct, ImportConfig, LogType } from '../types';
+import { PersonalizationAdapter, fsUtil, lookUpAttributes } from '../utils';
+
+export default class Audiences extends PersonalizationAdapter<ImportConfig> {
+  private mapperDirPath: string;
+  private audienceMapperDirPath: string;
+  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'];
+
+  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 },
+    };
+    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.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.audiencesUidMapper = {};
+  }
+
+  /**
+   * The function asynchronously imports audiences from a JSON file and creates them in the system.
+   */
+  async import() {
+    this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Audiences' }), 'info');
+
+    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));
+
+    if (existsSync(audiencesPath)) {
+      try {
+        const audiences = fsUtil.readFile(audiencesPath, true) as AudienceStruct[];
+        const attributesUid = (fsUtil.readFile(this.attributesMapperPath, true) as Record<string, string>) || {};
+
+        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);
+          }
+          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);
+        this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Audiences' }), 'info');
+      } catch (error) {
+        this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Audiences' }), 'error');
+        this.log(this.config, error, 'error');
+      }
+    }
+  }
+}

package/src/import/events.ts

@@ -0,0 +1,58 @@
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import { sanitizePath } from '@contentstack/cli-utilities';
+import { PersonalizationAdapter, fsUtil } from '../utils';
+import { APIConfig, EventStruct, ImportConfig, LogType } from '../types';
+
+export default class Events extends PersonalizationAdapter<ImportConfig> {
+  private mapperDirPath: string;
+  private eventMapperDirPath: string;
+  private eventsUidMapperPath: string;
+  private eventsUidMapper: Record<string, unknown>;
+  private personalizationConfig: ImportConfig['modules']['personalization'];
+  private eventsConfig: ImportConfig['modules']['personalization']['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 },
+    };
+    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.eventMapperDirPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.eventsConfig.dirName));
+    this.eventsUidMapperPath = resolve(sanitizePath(this.eventMapperDirPath), 'uid-mapping.json');
+    this.eventsUidMapper = {};
+  }
+
+  /**
+   * The function asynchronously imports attributes from a JSON file and creates them in the system.
+   */
+  async import() {
+    this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Events' }), 'info');
+
+    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));
+
+    if (existsSync(eventsPath)) {
+      try {
+        const events = fsUtil.readFile(eventsPath, true) as EventStruct[];
+
+        for (const event of events) {
+          const { key, description, uid } = event;
+          const eventsResponse = await this.createEvents({ key, description });
+          this.eventsUidMapper[uid] = eventsResponse?.uid ?? '';
+        }
+
+        fsUtil.writeFile(this.eventsUidMapperPath, this.eventsUidMapper);
+        this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Events' }), 'info');
+      } catch (error) {
+        this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Events' }), 'error');
+        this.log(this.config, error, 'error');
+      }
+    }
+  }
+}