@contentstack/cli-variants 0.0.1-alpha

package/lib/export/attributes.d.ts

@@ -0,0 +1,15 @@
+import { PersonalizationAdapter } from '../utils';
+import { PersonalizationConfig, ExportConfig } from '../types';
+export default class ExportAttributes extends PersonalizationAdapter<ExportConfig> {
+    readonly exportConfig: ExportConfig;
+    private attributesConfig;
+    private attributesFolderPath;
+    private attributes;
+    personalizationConfig: PersonalizationConfig;
+    constructor(exportConfig: ExportConfig);
+    start(): Promise<void>;
+    /**
+     * function to remove invalid keys from attributes object
+     */
+    sanitizeAttribs(): void;
+}

package/lib/export/attributes.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const omit_1 = __importDefault(require("lodash/omit"));
+const node_path_1 = require("node:path");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const utils_1 = require("../utils");
+class ExportAttributes extends utils_1.PersonalizationAdapter {
+    constructor(exportConfig) {
+        super({
+            config: exportConfig,
+            baseURL: exportConfig.modules.personalization.baseURL[exportConfig.region.name],
+            headers: { authtoken: exportConfig.auth_token, 'X-Project-Uid': exportConfig.project_id },
+        });
+        this.exportConfig = exportConfig;
+        this.personalizationConfig = exportConfig.modules.personalization;
+        this.attributesConfig = exportConfig.modules.attributes;
+        this.attributesFolderPath = (0, node_path_1.resolve)((0, cli_utilities_1.sanitizePath)(exportConfig.data), (0, cli_utilities_1.sanitizePath)(exportConfig.branchName || ''), (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.dirName), (0, cli_utilities_1.sanitizePath)(this.attributesConfig.dirName));
+        this.attributes = [];
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                (0, utils_1.log)(this.exportConfig, 'Starting attributes export', 'info');
+                yield utils_1.fsUtil.makeDirectory(this.attributesFolderPath);
+                this.attributes = (yield this.getAttributes());
+                if (!((_a = this.attributes) === null || _a === void 0 ? void 0 : _a.length)) {
+                    (0, utils_1.log)(this.exportConfig, 'No Attributes found with the given project!', 'info');
+                }
+                else {
+                    this.sanitizeAttribs();
+                    utils_1.fsUtil.writeFile((0, node_path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.attributesFolderPath), (0, cli_utilities_1.sanitizePath)(this.attributesConfig.fileName)), this.attributes);
+                    (0, utils_1.log)(this.exportConfig, 'All the attributes have been exported successfully!', 'success');
+                }
+            }
+            catch (error) {
+                (0, utils_1.log)(this.exportConfig, `Failed to export attributes!`, 'error');
+                (0, utils_1.log)(this.config, error, 'error');
+            }
+        });
+    }
+    /**
+     * function to remove invalid keys from attributes object
+     */
+    sanitizeAttribs() {
+        var _a;
+        this.attributes = ((_a = this.attributes) === null || _a === void 0 ? void 0 : _a.map((audience) => (0, omit_1.default)(audience, this.attributesConfig.invalidKeys))) || [];
+    }
+}
+exports.default = ExportAttributes;

package/lib/export/audiences.d.ts

@@ -0,0 +1,15 @@
+import { PersonalizationAdapter } from '../utils';
+import { PersonalizationConfig, ExportConfig } from '../types';
+export default class ExportAudiences extends PersonalizationAdapter<ExportConfig> {
+    readonly exportConfig: ExportConfig;
+    private audiencesConfig;
+    private audiencesFolderPath;
+    private audiences;
+    personalizationConfig: PersonalizationConfig;
+    constructor(exportConfig: ExportConfig);
+    start(): Promise<void>;
+    /**
+     * function to remove invalid keys from audience object
+     */
+    sanitizeAttribs(): void;
+}

package/lib/export/audiences.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const omit_1 = __importDefault(require("lodash/omit"));
+const node_path_1 = require("node:path");
+const utils_1 = require("../utils");
+class ExportAudiences extends utils_1.PersonalizationAdapter {
+    constructor(exportConfig) {
+        super({
+            config: exportConfig,
+            baseURL: exportConfig.modules.personalization.baseURL[exportConfig.region.name],
+            headers: { authtoken: exportConfig.auth_token, 'X-Project-Uid': exportConfig.project_id },
+        });
+        this.exportConfig = exportConfig;
+        this.personalizationConfig = exportConfig.modules.personalization;
+        this.audiencesConfig = exportConfig.modules.audiences;
+        this.audiencesFolderPath = (0, node_path_1.resolve)(exportConfig.data, exportConfig.branchName || '', this.personalizationConfig.dirName, this.audiencesConfig.dirName);
+        this.audiences = [];
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                (0, utils_1.log)(this.exportConfig, 'Starting audiences export', 'info');
+                yield utils_1.fsUtil.makeDirectory(this.audiencesFolderPath);
+                this.audiences = (yield this.getAudiences());
+                if (!((_a = this.audiences) === null || _a === void 0 ? void 0 : _a.length)) {
+                    (0, utils_1.log)(this.exportConfig, 'No Audiences found with the given project!', 'info');
+                    return;
+                }
+                else {
+                    this.sanitizeAttribs();
+                    utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.audiencesFolderPath, this.audiencesConfig.fileName), this.audiences);
+                    (0, utils_1.log)(this.exportConfig, 'All the audiences have been exported successfully!', 'success');
+                    return;
+                }
+            }
+            catch (error) {
+                (0, utils_1.log)(this.exportConfig, `Failed to export audiences!`, 'error');
+                (0, utils_1.log)(this.config, error, 'error');
+            }
+        });
+    }
+    /**
+     * function to remove invalid keys from audience object
+     */
+    sanitizeAttribs() {
+        var _a;
+        this.audiences = ((_a = this.audiences) === null || _a === void 0 ? void 0 : _a.map((audience) => (0, omit_1.default)(audience, this.audiencesConfig.invalidKeys))) || [];
+    }
+}
+exports.default = ExportAudiences;

package/lib/export/events.d.ts

@@ -0,0 +1,15 @@
+import { PersonalizationAdapter } from '../utils';
+import { PersonalizationConfig, ExportConfig } from '../types';
+export default class ExportEvents extends PersonalizationAdapter<ExportConfig> {
+    readonly exportConfig: ExportConfig;
+    private eventsConfig;
+    private eventsFolderPath;
+    private events;
+    personalizationConfig: PersonalizationConfig;
+    constructor(exportConfig: ExportConfig);
+    start(): Promise<void>;
+    /**
+     * function to remove invalid keys from event object
+     */
+    sanitizeAttribs(): void;
+}

package/lib/export/events.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const omit_1 = __importDefault(require("lodash/omit"));
+const node_path_1 = require("node:path");
+const utils_1 = require("../utils");
+class ExportEvents extends utils_1.PersonalizationAdapter {
+    constructor(exportConfig) {
+        super({
+            config: exportConfig,
+            baseURL: exportConfig.modules.personalization.baseURL[exportConfig.region.name],
+            headers: { authtoken: exportConfig.auth_token, 'X-Project-Uid': exportConfig.project_id },
+        });
+        this.exportConfig = exportConfig;
+        this.personalizationConfig = exportConfig.modules.personalization;
+        this.eventsConfig = exportConfig.modules.events;
+        this.eventsFolderPath = (0, node_path_1.resolve)(exportConfig.data, exportConfig.branchName || '', this.personalizationConfig.dirName, this.eventsConfig.dirName);
+        this.events = [];
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                (0, utils_1.log)(this.exportConfig, 'Starting events export', 'info');
+                yield utils_1.fsUtil.makeDirectory(this.eventsFolderPath);
+                this.events = (yield this.getEvents());
+                if (!((_a = this.events) === null || _a === void 0 ? void 0 : _a.length)) {
+                    (0, utils_1.log)(this.exportConfig, 'No Events found with the given project!', 'info');
+                    return;
+                }
+                else {
+                    this.sanitizeAttribs();
+                    utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.eventsFolderPath, this.eventsConfig.fileName), this.events);
+                    (0, utils_1.log)(this.exportConfig, 'All the events have been exported successfully!', 'success');
+                    return;
+                }
+            }
+            catch (error) {
+                (0, utils_1.log)(this.exportConfig, `Failed to export events!`, 'error');
+                (0, utils_1.log)(this.config, error, 'error');
+            }
+        });
+    }
+    /**
+     * function to remove invalid keys from event object
+     */
+    sanitizeAttribs() {
+        var _a;
+        this.events = ((_a = this.events) === null || _a === void 0 ? void 0 : _a.map((event) => (0, omit_1.default)(event, this.eventsConfig.invalidKeys))) || [];
+    }
+}
+exports.default = ExportEvents;

package/lib/export/experiences.d.ts

@@ -0,0 +1,9 @@
+import { PersonalizationConfig, ExportConfig } from '../types';
+import { PersonalizationAdapter } from '../utils';
+export default class ExportExperiences extends PersonalizationAdapter<ExportConfig> {
+    private experiencesFolderPath;
+    exportConfig: ExportConfig;
+    personalizationConfig: PersonalizationConfig;
+    constructor(exportConfig: ExportConfig);
+    start(): Promise<void>;
+}

package/lib/export/experiences.js

@@ -0,0 +1,99 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const utils_1 = require("../utils");
+class ExportExperiences extends utils_1.PersonalizationAdapter {
+    constructor(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((0, cli_utilities_1.sanitizePath)(exportConfig.data), (0, cli_utilities_1.sanitizePath)(exportConfig.branchName || ''), (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.dirName), 'experiences');
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            try {
+                // get all experiences
+                // loop through experiences and get content types attached to it
+                // write experiences in to a file
+                (0, utils_1.log)(this.exportConfig, 'Starting experiences export', 'info');
+                yield utils_1.fsUtil.makeDirectory(this.experiencesFolderPath);
+                const experiences = (yield this.getExperiences()) || [];
+                if (!experiences || (experiences === null || experiences === void 0 ? void 0 : experiences.length) < 1) {
+                    (0, utils_1.log)(this.exportConfig, 'No Experiences found with the give project', 'info');
+                    return;
+                }
+                utils_1.fsUtil.writeFile(path.resolve((0, cli_utilities_1.sanitizePath)(this.experiencesFolderPath), 'experiences.json'), experiences);
+                const experienceToVariantsStrList = [];
+                const experienceToContentTypesMap = {};
+                for (let experience of experiences) {
+                    // create id mapper for experience to variants
+                    let variants = (_b = (_a = experience === null || experience === void 0 ? void 0 : experience._cms) === null || _a === void 0 ? void 0 : _a.variants) !== null && _b !== void 0 ? _b : {};
+                    Object.keys(variants).forEach((variantShortId) => {
+                        const experienceToVariantsStr = `${experience.uid}-${variantShortId}-${variants[variantShortId]}`;
+                        experienceToVariantsStrList.push(experienceToVariantsStr);
+                    });
+                    try {
+                        // fetch content of experience
+                        const { variant_groups: [variantGroup] = [] } = (yield this.getVariantGroup({ experienceUid: experience.uid })) || {};
+                        if ((_c = variantGroup === null || variantGroup === void 0 ? void 0 : variantGroup.content_types) === null || _c === void 0 ? void 0 : _c.length) {
+                            experienceToContentTypesMap[experience.uid] = variantGroup.content_types;
+                        }
+                    }
+                    catch (error) {
+                        (0, utils_1.log)(this.exportConfig, `Failed to fetch content types of experience ${experience.name}`, 'error');
+                    }
+                }
+                utils_1.fsUtil.writeFile(path.resolve((0, cli_utilities_1.sanitizePath)(this.experiencesFolderPath), 'experiences-variants-ids.json'), experienceToVariantsStrList);
+                utils_1.fsUtil.writeFile(path.resolve((0, cli_utilities_1.sanitizePath)(this.experiencesFolderPath), 'experiences-content-types.json'), experienceToContentTypesMap);
+                (0, utils_1.log)(this.exportConfig, 'All the experiences have been exported successfully!', 'success');
+            }
+            catch (error) {
+                (0, utils_1.log)(this.exportConfig, `Failed to export experiences!`, 'error');
+                (0, utils_1.log)(this.config, error, 'error');
+            }
+        });
+    }
+}
+exports.default = ExportExperiences;

package/lib/export/index.d.ts

@@ -0,0 +1,9 @@
+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';
+export declare const Export: {
+    VariantEntries: typeof VariantEntries;
+};

package/lib/export/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Export = exports.ExportAttributes = exports.ExportAudiences = exports.ExportEvents = exports.ExportExperiences = exports.ExportProjects = void 0;
+var projects_1 = require("./projects");
+Object.defineProperty(exports, "ExportProjects", { enumerable: true, get: function () { return __importDefault(projects_1).default; } });
+var experiences_1 = require("./experiences");
+Object.defineProperty(exports, "ExportExperiences", { enumerable: true, get: function () { return __importDefault(experiences_1).default; } });
+const variant_entries_1 = __importDefault(require("./variant-entries"));
+var events_1 = require("./events");
+Object.defineProperty(exports, "ExportEvents", { enumerable: true, get: function () { return __importDefault(events_1).default; } });
+var audiences_1 = require("./audiences");
+Object.defineProperty(exports, "ExportAudiences", { enumerable: true, get: function () { return __importDefault(audiences_1).default; } });
+var attributes_1 = require("./attributes");
+Object.defineProperty(exports, "ExportAttributes", { enumerable: true, get: function () { return __importDefault(attributes_1).default; } });
+// NOTE Acting as namespace to avoid the same class name conflicts in other modules
+exports.Export = {
+    VariantEntries: variant_entries_1.default,
+};

package/lib/export/projects.d.ts

@@ -0,0 +1,9 @@
+import { ExportConfig, PersonalizationConfig } from '../types';
+import { PersonalizationAdapter } from '../utils';
+export default class ExportProjects extends PersonalizationAdapter<ExportConfig> {
+    private projectFolderPath;
+    exportConfig: ExportConfig;
+    personalizationConfig: PersonalizationConfig;
+    constructor(exportConfig: ExportConfig);
+    start(): Promise<void>;
+}

package/lib/export/projects.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const utils_1 = require("../utils");
+class ExportProjects extends utils_1.PersonalizationAdapter {
+    constructor(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((0, cli_utilities_1.sanitizePath)(exportConfig.data), (0, cli_utilities_1.sanitizePath)(exportConfig.branchName || ''), (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.dirName), 'projects');
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                (0, utils_1.log)(this.exportConfig, 'Starting projects export', 'info');
+                yield utils_1.fsUtil.makeDirectory(this.projectFolderPath);
+                const project = yield this.projects({ connectedStackApiKey: this.exportConfig.apiKey });
+                if (!project || (project === null || project === void 0 ? void 0 : project.length) < 1) {
+                    (0, utils_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 = (_a = project[0]) === null || _a === void 0 ? void 0 : _a.uid;
+                utils_1.fsUtil.writeFile(path.resolve((0, cli_utilities_1.sanitizePath)(this.projectFolderPath), 'projects.json'), project);
+                (0, utils_1.log)(this.exportConfig, 'Project exported successfully!', 'success');
+            }
+            catch (error) {
+                (0, utils_1.log)(this.exportConfig, `Failed to export projects!`, 'error');
+                throw error;
+            }
+        });
+    }
+}
+exports.default = ExportProjects;

package/lib/export/variant-entries.d.ts

@@ -0,0 +1,18 @@
+import { ExportConfig } from '../types';
+import VariantAdapter, { VariantHttpClient } from '../utils/variant-api-adapter';
+export default class VariantEntries extends VariantAdapter<VariantHttpClient<ExportConfig>> {
+    readonly config: ExportConfig;
+    entriesDirPath: string;
+    variantEntryBasePath: string;
+    constructor(config: ExportConfig);
+    /**
+     * 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:
+     */
+    exportVariantEntry(options: {
+        locale: string;
+        contentTypeUid: string;
+        entries: Record<string, any>[];
+    }): Promise<void>;
+}

package/lib/export/variant-entries.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const variant_api_adapter_1 = __importStar(require("../utils/variant-api-adapter"));
+const utils_1 = require("../utils");
+class VariantEntries extends variant_api_adapter_1.default {
+    constructor(config) {
+        const conf = {
+            config,
+            httpClient: true,
+            baseURL: config.host,
+            Adapter: (variant_api_adapter_1.VariantHttpClient),
+            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.config = config;
+        this.entriesDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(config.data), (0, cli_utilities_1.sanitizePath)(config.branchName || ''), (0, cli_utilities_1.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:
+     */
+    exportVariantEntry(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.entriesDirPath), (0, cli_utilities_1.sanitizePath)(content_type_uid), (0, cli_utilities_1.sanitizePath)(locale), (0, cli_utilities_1.sanitizePath)(variantEntry.dirName), (0, cli_utilities_1.sanitizePath)(entry.uid));
+                const variantEntriesFs = new cli_utilities_1.FsUtility({
+                    isArray: true,
+                    keepMetadata: false,
+                    moduleName: 'variant-entry',
+                    basePath: variantEntryBasePath,
+                    indexFileName: variantEntry.fileName,
+                    chunkFileSize: variantEntry.chunkFileSize || 1,
+                    createDirIfNotExist: false,
+                });
+                const callback = (variantEntries) => {
+                    if (variantEntries === null || variantEntries === void 0 ? void 0 : variantEntries.length) {
+                        if (!(0, fs_1.existsSync)(variantEntryBasePath)) {
+                            (0, fs_1.mkdirSync)(variantEntryBasePath, { recursive: true });
+                        }
+                        variantEntriesFs.writeIntoFile(variantEntries);
+                    }
+                };
+                try {
+                    yield this.variantInstance.variantEntries({
+                        callback,
+                        getAllData: true,
+                        content_type_uid,
+                        entry_uid: entry.uid,
+                        locale,
+                    });
+                    if ((0, fs_1.existsSync)(variantEntryBasePath)) {
+                        variantEntriesFs.completeFile(true);
+                        (0, utils_1.log)(this.config, `Exported variant entries of type '${entry.title} (${entry.uid})' locale '${locale}'`, 'info');
+                    }
+                }
+                catch (error) {
+                    (0, utils_1.log)(this.config, `Error exporting variant entries of type '${entry.title} (${entry.uid})' locale '${locale}'`, 'error');
+                    (0, utils_1.log)(this.config, error, 'error');
+                }
+            }
+        });
+    }
+}
+exports.default = VariantEntries;

package/lib/import/attribute.d.ts

@@ -0,0 +1,17 @@
+import { PersonalizationAdapter } from '../utils';
+import { ImportConfig, LogType } from '../types';
+export default class Attribute extends PersonalizationAdapter<ImportConfig> {
+    readonly config: ImportConfig;
+    private readonly log;
+    private mapperDirPath;
+    private attrMapperDirPath;
+    private attributesUidMapperPath;
+    private attributesUidMapper;
+    private personalizationConfig;
+    private attributeConfig;
+    constructor(config: ImportConfig, log?: LogType);
+    /**
+     * The function asynchronously imports attributes from a JSON file and creates them in the system.
+     */
+    import(): Promise<void>;
+}