Variants changes

packages/contentstack-command/src/interfaces/index.ts

@@ -2,8 +2,8 @@ export interface Region {
   name: string;
   cma: string;
   cda: string;
-  uiHost: string;
   developerHubUrl: string;
-  launchHubUrl: string;
   personalizeUrl: string;
+  launchHubUrl: string;
+  uiHost: string;
 }

packages/contentstack-export/src/commands/cm/stacks/export.ts

@@ -105,6 +105,7 @@ export default class ExportCommand extends Command {
       let exportConfig = await setupExportConfig(flags);
       // Note setting host to create cma client
       exportConfig.host = this.cmaHost;
+      exportConfig.region = this.region;
       exportConfig.developerHubBaseUrl = this.developerHubUrl;
       exportDir = exportConfig.cliLogsPath || exportConfig.data || exportConfig.exportDir;
       const managementAPIClient: ContentstackClient = await managementSDKClient(exportConfig);

packages/contentstack-export/src/config/index.ts

@@ -33,6 +33,7 @@ const config: DefaultConfig = {
       'content-types',
       'custom-roles',
       'workflows',
+      'personalization',
       'entries',
       'labels',
       'marketplace-apps',
@@ -143,6 +144,47 @@ const config: DefaultConfig = {
       dependencies: ['locales', 'content-types'],
       exportVersions: false,
     },
+    personalization: {
+      baseURL: {
+        NA: 'https://personalization-api.contentstack.com',
+      },
+      dirName: 'personalization',
+      exportOrder: ['attributes', 'audiences', 'events', 'experiences'],
+      projects: {
+        dirName: 'projects',
+        fileName: 'projects.json',
+      },
+      attributes: {
+        dirName: 'attributes',
+        fileName: 'attributes.json',
+      },
+      audiences: {
+        dirName: 'audiences',
+        fileName: 'audiences.json',
+      },
+      events: {
+        dirName: 'events',
+        fileName: 'events.json',
+      },
+      experiences: {
+        dirName: 'experiences',
+        fileName: 'experiences.json',
+      },
+    },
+    variantEntry: {
+      serveMockData: false,
+      dirName: 'variants',
+      fileName: 'index.json',
+      chunkFileSize: 1,
+      query: {
+        skip: 0,
+        limit: 100,
+        include_variant: false,
+        include_count: true,
+        include_publish_details: true,
+      },
+      mockDataPath: './variant-mock-data.json',
+    },
     extensions: {
       dirName: 'extensions',
       fileName: 'extensions.json',
@@ -166,7 +208,46 @@ const config: DefaultConfig = {
       dirName: 'taxonomies',
       fileName: 'taxonomies.json',
       invalidKeys: ['updated_at', 'created_by', 'updated_by', 'stackHeaders', 'urlPath', 'created_at'],
-    }
+    },
+    events: {
+      dirName: 'events',
+      fileName: 'events.json',
+      invalidKeys: [
+        'updatedAt',
+        'createdBy',
+        'updatedBy',
+        '_id',
+        'createdAt',
+        'createdByUserName',
+        'updatedByUserName',
+      ],
+    },
+    audiences: {
+      dirName: 'audiences',
+      fileName: 'audiences.json',
+      invalidKeys: [
+        'updatedAt',
+        'createdBy',
+        'updatedBy',
+        '_id',
+        'createdAt',
+        'createdByUserName',
+        'updatedByUserName',
+      ],
+    },
+    attributes: {
+      dirName: 'attributes',
+      fileName: 'attributes.json',
+      invalidKeys: [
+        'updatedAt',
+        'createdBy',
+        'updatedBy',
+        '_id',
+        'createdAt',
+        'createdByUserName',
+        'updatedByUserName',
+      ],
+    },
   },
   languagesCode: [
     'af-za',
@@ -393,6 +474,7 @@ const config: DefaultConfig = {
     stacks: '/stacks/',
   },
   preserveStackVersion: false,
+  personalizationEnabled: false,
   fetchConcurrency: 5,
   writeConcurrency: 5,
   developerHubBaseUrl: '',

packages/contentstack-export/src/export/modules/entries.ts

@@ -1,5 +1,7 @@
 import * as path from 'path';
 import { ContentstackClient, FsUtility } from '@contentstack/cli-utilities';
+import { LogType, Export, ExportProjects } from '@contentstack/cli-variants';
+
 import { log, formatError, fsUtil } from '../../utils';
 import { ExportConfig, ModuleClassParams } from '../../types';
 import BaseClass, { ApiOptions } from './base-class';
@@ -19,17 +21,24 @@ export default class EntriesExport extends BaseClass {
     batchLimit?: number;
     exportVersions: boolean;
   };
+  private variantEntries!: any;
   private entriesDirPath: string;
   private localesFilePath: string;
   private schemaFilePath: string;
   private entriesFileHelper: FsUtility;
+  private projectInstance: ExportProjects;
+  public exportVariantEntry: boolean = false;
 
   constructor({ exportConfig, stackAPIClient }: ModuleClassParams) {
     super({ exportConfig, stackAPIClient });
     this.stackAPIClient = stackAPIClient;
     this.exportConfig = exportConfig;
     this.entriesConfig = exportConfig.modules.entries;
-    this.entriesDirPath = path.resolve(sanitizePath(exportConfig.data), sanitizePath(exportConfig.branchName || ''), sanitizePath(this.entriesConfig.dirName));
+    this.entriesDirPath = path.resolve(
+      sanitizePath(exportConfig.data),
+      sanitizePath(exportConfig.branchName || ''),
+      sanitizePath(this.entriesConfig.dirName),
+    );
     this.localesFilePath = path.resolve(
       sanitizePath(exportConfig.data),
       sanitizePath(exportConfig.branchName || ''),
@@ -42,6 +51,7 @@ export default class EntriesExport extends BaseClass {
       sanitizePath(exportConfig.modules.content_types.dirName),
       'schema.json',
     );
+    this.projectInstance = new ExportProjects(this.exportConfig);
   }
 
   async start() {
@@ -53,13 +63,26 @@ export default class EntriesExport extends BaseClass {
         log(this.exportConfig, 'No content types found to export entries', 'info');
         return;
       }
+
+      // NOTE Check if variant is enabled in specific stack
+      if (this.exportConfig.personalizationEnabled) {
+        let project_id;
+        try {
+          const project = await this.projectInstance.projects({ connectedStackApiKey: this.exportConfig.apiKey });
+
+          if (project && project[0]?.uid) {
+            project_id = project[0].uid;
+            this.exportVariantEntry = true;
+          }
+
+          this.variantEntries = new Export.VariantEntries(Object.assign(this.exportConfig, { project_id }));
+        } catch (error) {
+          log(this.exportConfig, `Failed to export variant entries ${error}`, 'error');
+        }
+      }
+
       const entryRequestOptions = this.createRequestObjects(locales, contentTypes);
       for (let entryRequestOption of entryRequestOptions) {
-        // log(
-        //   this.exportConfig,
-        //   `Starting export of entries of content type - ${entryRequestOption.contentType} locale - ${entryRequestOption.locale}`,
-        //   'info',
-        // );
         await this.getEntries(entryRequestOption);
         this.entriesFileHelper?.completeFile(true);
         log(
@@ -71,7 +94,7 @@ export default class EntriesExport extends BaseClass {
       log(this.exportConfig, 'Entries exported successfully', 'success');
     } catch (error) {
       log(this.exportConfig, `Failed to export entries ${formatError(error)}`, 'error');
-      throw new Error('Failed to export entries');
+      // throw new Error('Failed to export entries');
     }
   }
 
@@ -119,7 +142,11 @@ export default class EntriesExport extends BaseClass {
 
     if (Array.isArray(entriesSearchResponse.items) && entriesSearchResponse.items.length > 0) {
       if (options.skip === 0) {
-        const entryBasePath = path.join(sanitizePath(this.entriesDirPath), sanitizePath(options.contentType), sanitizePath(options.locale));
+        const entryBasePath = path.join(
+          sanitizePath(this.entriesDirPath),
+          sanitizePath(options.contentType),
+          sanitizePath(options.locale),
+        );
         await fsUtil.makeDirectory(entryBasePath);
         this.entriesFileHelper = new FsUtility({
           moduleName: 'entries',
@@ -132,14 +159,29 @@ export default class EntriesExport extends BaseClass {
       }
       this.entriesFileHelper.writeIntoFile(entriesSearchResponse.items, { mapKeyVal: true });
       if (this.entriesConfig.exportVersions) {
-        let versionedEntryPath = path.join(sanitizePath(this.entriesDirPath), sanitizePath(options.contentType),sanitizePath(options.locale), 'versions');
+        let versionedEntryPath = path.join(
+          sanitizePath(this.entriesDirPath),
+          sanitizePath(options.contentType),
+          sanitizePath(options.locale),
+          'versions',
+        );
         fsUtil.makeDirectory(versionedEntryPath);
         await this.fetchEntriesVersions(entriesSearchResponse.items, {
           locale: options.locale,
           contentType: options.contentType,
           versionedEntryPath,
         });
       }
+
+      // NOTE Export all base entry specific 'variant entries'
+      if (this.exportVariantEntry) {
+        await this.variantEntries.exportVariantEntry({
+          locale: options.locale,
+          contentTypeUid: options.contentType,
+          entries: entriesSearchResponse.items,
+        });
+      }
+
       options.skip += this.entriesConfig.limit || 100;
       if (options.skip >= entriesSearchResponse.count) {
         return Promise.resolve(true);
@@ -153,7 +195,10 @@ export default class EntriesExport extends BaseClass {
     options: { locale: string; contentType: string; versionedEntryPath: string },
   ): Promise<void> {
     const onSuccess = ({ response, apiData: entry }: any) => {
-      fsUtil.writeFile(path.join(sanitizePath(options.versionedEntryPath), sanitizePath(`${entry.uid}.json`)), response);
+      fsUtil.writeFile(
+        path.join(sanitizePath(options.versionedEntryPath), sanitizePath(`${entry.uid}.json`)),
+        response,
+      );
       log(
         this.exportConfig,
         `Exported versioned entries of type '${options.contentType}' locale '${options.locale}'`,

packages/contentstack-export/src/export/modules/personalization.ts

@@ -0,0 +1,49 @@
+import {
+  ExportProjects,
+  ExportExperiences,
+  ExportEvents,
+  ExportAttributes,
+  ExportAudiences,
+} from '@contentstack/cli-variants';
+
+import { log, formatError } from '../../utils';
+import { ModuleClassParams, ExportConfig } from '../../types';
+
+export default class ExportPersonalization {
+  public exportConfig: ExportConfig;
+  constructor({ exportConfig }: ModuleClassParams) {
+    this.exportConfig = exportConfig;
+  }
+
+  async start(): Promise<void> {
+    try {
+      if (this.exportConfig.management_token) {
+        log(this.exportConfig, 'Skipping Personalize project export when using management token', 'info');
+        return;
+      }
+      await new ExportProjects(this.exportConfig).start();
+      if (this.exportConfig.personalizationEnabled) {
+        const moduleMapper = {
+          events: new ExportEvents(this.exportConfig),
+          attributes: new ExportAttributes(this.exportConfig),
+          audiences: new ExportAudiences(this.exportConfig),
+          experiences: new ExportExperiences(this.exportConfig),
+        };
+
+        const order: (keyof typeof moduleMapper)[] = this.exportConfig.modules.personalization
+          .exportOrder as (keyof typeof moduleMapper)[];
+
+        for (const module of order) {
+          if (moduleMapper[module]) {
+            await moduleMapper[module].start();
+          } else {
+            log(this.exportConfig, `No implementation found for the module ${module}`, 'info');
+          }
+        }
+      }
+    } catch (error) {
+      this.exportConfig.personalizationEnabled = false;
+      log(this.exportConfig, error, 'error');
+    }
+  }
+}

packages/contentstack-export/src/types/default-config.ts

@@ -1,5 +1,9 @@
 import { Modules } from '.';
 
+interface AnyProperty {
+  [propName: string]: any;
+}
+
 export default interface DefaultConfig {
   contentVersion: number;
   versioning: boolean;
@@ -118,6 +122,22 @@ export default interface DefaultConfig {
       dependencies?: Modules[];
       exportVersions: boolean;
     };
+    personalization: {
+      dirName: string;
+      baseURL: Record<string, string>;
+    } & AnyProperty;
+    variantEntry: {
+      dirName: string;
+      fileName: string;
+      chunkFileSize: number;
+      query: {
+        skip: number;
+        limit: number;
+        include_variant: boolean;
+        include_count: boolean;
+        include_publish_details: boolean;
+      } & AnyProperty;
+    } & AnyProperty;
     extensions: {
       dirName: string;
       fileName: string;
@@ -152,6 +172,24 @@ export default interface DefaultConfig {
       invalidKeys: string[];
       dependencies?: Modules[];
     };
+    events: {
+      dirName: string;
+      fileName: string;
+      invalidKeys: string[];
+      dependencies?: Modules[];
+    };
+    audiences: {
+      dirName: string;
+      fileName: string;
+      invalidKeys: string[];
+      dependencies?: Modules[];
+    };
+    attributes: {
+      dirName: string;
+      fileName: string;
+      invalidKeys: string[];
+      dependencies?: Modules[];
+    };
   };
   languagesCode: string[];
   apis: {
@@ -169,6 +207,7 @@ export default interface DefaultConfig {
     stacks: string;
   };
   preserveStackVersion: boolean;
+  personalizationEnabled: boolean;
   fetchConcurrency: number;
   writeConcurrency: number;
   developerHubBaseUrl: string;