@contentstack/cli-variants 0.0.1-alpha

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

@@ -0,0 +1,98 @@
+import VariantAdapter, { VariantHttpClient } from '../utils/variant-api-adapter';
+import { ImportConfig, ContentTypeStruct, VariantEntryStruct, ImportHelperMethodsConfig, EntryDataForVariantEntries } from '../types';
+export default class VariantEntries extends VariantAdapter<VariantHttpClient<ImportConfig>> {
+    readonly config: ImportConfig & {
+        helpers?: ImportHelperMethodsConfig;
+    };
+    entriesDirPath: string;
+    entriesMapperPath: string;
+    variantEntryBasePath: string;
+    variantIdList: Record<string, unknown>;
+    personalizationConfig: ImportConfig['modules']['personalization'];
+    taxonomies: Record<string, unknown>;
+    assetUrlMapper: Record<string, any>;
+    assetUidMapper: Record<string, any>;
+    entriesUidMapper: Record<string, any>;
+    private installedExtensions;
+    private failedVariantPath;
+    private failedVariantEntries;
+    private environments;
+    constructor(config: ImportConfig & {
+        helpers?: ImportHelperMethodsConfig;
+    });
+    /**
+     * This TypeScript function asynchronously imports backupDir from a JSON file and processes the entries
+     * for variant entries.
+     * @returns If the file at the specified file path exists and contains backupDir, the function will parse
+     * the JSON backupDir and iterate over each entry to import variant entries using the
+     * `importVariantEntries` method. If the `entriesForVariants` array is empty, the function will log a
+     * message indicating that no entries were found and return.
+     */
+    import(): Promise<void>;
+    /**
+     * The function `importVariantEntries` asynchronously imports variant entries using file system
+     * utility in TypeScript.
+     * @param {EntryDataForVariantEntries} entriesForVariant - EntryDataForVariantEntries {
+     */
+    importVariantEntries(entriesForVariant: EntryDataForVariantEntries): Promise<void>;
+    /**
+     * The function `handleConcurrency` processes variant entries in batches with a specified concurrency
+     * level and handles API calls for creating variant entries.
+     * @param {VariantEntryStruct[]} variantEntries - The `variantEntries` parameter is an array of
+     * `VariantEntryStruct` objects. It seems like this function is handling concurrency for processing
+     * these entries in batches. The function chunks the `variantEntries` array into smaller batches and
+     * then processes each batch asynchronously using `Promise.allSettled`. It also
+     * @param {EntryDataForVariantEntries} entriesForVariant - The `entriesForVariant` parameter seems to
+     * be an object containing the following properties:
+     * @returns The `handleConcurrency` function processes variant entries in batches, creating variant
+     * entries using the `createVariantEntry` method and handling the API response using
+     * `Promise.allSettled`. The function also includes logic to handle variant IDs and delays between
+     * batch processing.
+     */
+    handleConcurrency(contentType: ContentTypeStruct, variantEntries: VariantEntryStruct[], entriesForVariant: EntryDataForVariantEntries): Promise<void>;
+    /**
+     * Serializes the change set of a entry variant.
+     * @param variantEntry - The entry variant to serialize.
+     * @returns The serialized change set as a record.
+     */
+    serializeChangeSet(variantEntry: VariantEntryStruct): Record<string, any>;
+    /**
+     * The function `handleVariantEntryRelationalData` processes relational data for a entry variant
+     * based on the provided content type and configuration helpers.
+     * @param {ContentTypeStruct} contentType - The `contentType` parameter in the
+     * `handleVariantEntryRelationalData` function is of type `ContentTypeStruct`. It is used to define
+     * the structure of the content type being processed within the function. This parameter likely
+     * contains information about the schema and configuration of the content type.
+     * @param {VariantEntryStruct} variantEntry - The `variantEntry` parameter in the
+     * `handleVariantEntryRelationalData` function is a data structure that represents a entry variant.
+     * It is of type `VariantEntryStruct` and contains information related to a specific entry variant.
+     * This function is responsible for performing various operations on the `variantEntry`
+     * @returns The function `handleVariantEntryRelationalData` returns the `variantEntry` after
+     * performing various lookups and replacements on it based on the provided `contentType` and
+     * `config.helpers`.
+     */
+    handleVariantEntryRelationalData(contentType: ContentTypeStruct, variantEntry: VariantEntryStruct): VariantEntryStruct;
+    /**
+     * Updates the file fields of a entry variant to support lookup asset logic.
+     * Lookup asset expects file fields to be an object instead of a string. So here we are updating the file fields to be an object. Object has two keys: `uid` and `filename`. `uid` is the asset UID and `filename` is the name of the file. Used a dummy value for the filename. This is a temporary fix and will be updated in the future.
+     * @param variantEntry - The entry variant to update.
+     */
+    updateFileFields(variantEntry: VariantEntryStruct): void;
+    /**
+     * Publishes variant entries in batch for a given entry UID and content type.
+     * @param batch - An array of VariantEntryStruct objects representing the variant entries to be published.
+     * @param entryUid - The UID of the entry for which the variant entries are being published.
+     * @param content_type - The UID of the content type of the entry.
+     * @returns A Promise that resolves when all variant entries have been published.
+     */
+    publishVariantEntries(batch: VariantEntryStruct[], entryUid: string, content_type: string): Promise<void>;
+    /**
+     * Serializes the publish entries of a variant.
+     * @param variantEntry - The entry variant to serialize.
+     * @returns An object containing the serialized publish entries.
+     */
+    serializePublishEntries(variantEntry: VariantEntryStruct): {
+        environments: Array<string>;
+        locales: Array<string>;
+    };
+}

package/lib/import/variant-entries.js

@@ -0,0 +1,407 @@
+"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());
+    });
+};
+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 chunk_1 = __importDefault(require("lodash/chunk"));
+const entries_1 = __importDefault(require("lodash/entries"));
+const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
+const forEach_1 = __importDefault(require("lodash/forEach"));
+const indexOf_1 = __importDefault(require("lodash/indexOf"));
+const path_1 = require("path");
+const fs_1 = require("fs");
+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.modules.personalization.project_id,
+            },
+        };
+        super(Object.assign((0, omit_1.default)(config, ['helpers']), conf));
+        this.config = config;
+        this.entriesMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(config.backupDir), (0, cli_utilities_1.sanitizePath)(config.branchName || ''), 'mapper', 'entries');
+        this.personalizationConfig = this.config.modules.personalization;
+        this.entriesDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(config.backupDir), (0, cli_utilities_1.sanitizePath)(config.branchName || ''), (0, cli_utilities_1.sanitizePath)(config.modules.entries.dirName));
+        this.failedVariantPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.entriesMapperPath), 'failed-entry-variants.json');
+        this.failedVariantEntries = new Map();
+    }
+    /**
+     * This TypeScript function asynchronously imports backupDir from a JSON file and processes the entries
+     * for variant entries.
+     * @returns If the file at the specified file path exists and contains backupDir, the function will parse
+     * the JSON backupDir and iterate over each entry to import variant entries using the
+     * `importVariantEntries` method. If the `entriesForVariants` array is empty, the function will log a
+     * message indicating that no entries were found and return.
+     */
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filePath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.entriesMapperPath), 'data-for-variant-entry.json');
+            const variantIdPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.dirName), (0, cli_utilities_1.sanitizePath)(this.personalizationConfig.experiences.dirName), 'variants-uid-mapping.json');
+            if (!(0, fs_1.existsSync)(filePath)) {
+                (0, utils_1.log)(this.config, this.messages.IMPORT_ENTRY_NOT_FOUND, 'info');
+                return;
+            }
+            if (!(0, fs_1.existsSync)(variantIdPath)) {
+                (0, utils_1.log)(this.config, this.messages.EMPTY_VARIANT_UID_DATA, 'error');
+                return;
+            }
+            const entriesForVariants = utils_1.fsUtil.readFile(filePath, true);
+            if ((0, isEmpty_1.default)(entriesForVariants)) {
+                (0, utils_1.log)(this.config, this.messages.IMPORT_ENTRY_NOT_FOUND, 'info');
+                return;
+            }
+            const entriesUidMapperPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.entriesMapperPath), 'uid-mapping.json');
+            const assetUidMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'assets', 'uid-mapping.json');
+            const assetUrlMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'assets', 'url-mapping.json');
+            const taxonomiesPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.config.modules.taxonomies.dirName), 'terms', 'success.json');
+            const marketplaceAppMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'marketplace_apps', 'uid-mapping.json');
+            const envPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'environments', 'environments.json');
+            // NOTE Read and store list of variant IDs
+            this.variantIdList = (utils_1.fsUtil.readFile(variantIdPath, true) || {});
+            if ((0, isEmpty_1.default)(this.variantIdList)) {
+                (0, utils_1.log)(this.config, this.messages.EMPTY_VARIANT_UID_DATA, 'info');
+                return;
+            }
+            // NOTE entry relational data lookup dependencies.
+            this.entriesUidMapper = (utils_1.fsUtil.readFile(entriesUidMapperPath, true) || {});
+            this.installedExtensions = (utils_1.fsUtil.readFile(marketplaceAppMapperPath) || { extension_uid: {} })
+                .extension_uid;
+            this.taxonomies = (utils_1.fsUtil.readFile(taxonomiesPath, true) || {});
+            this.assetUidMapper = (utils_1.fsUtil.readFile(assetUidMapperPath, true) || {});
+            this.assetUrlMapper = (utils_1.fsUtil.readFile(assetUrlMapperPath, true) || {});
+            this.environments = (utils_1.fsUtil.readFile(envPath, true) || {});
+            for (const entriesForVariant of entriesForVariants) {
+                yield this.importVariantEntries(entriesForVariant);
+            }
+            (0, utils_1.log)(this.config, 'All the entries variants have been imported & published successfully', 'success');
+        });
+    }
+    /**
+     * The function `importVariantEntries` asynchronously imports variant entries using file system
+     * utility in TypeScript.
+     * @param {EntryDataForVariantEntries} entriesForVariant - EntryDataForVariantEntries {
+     */
+    importVariantEntries(entriesForVariant) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const variantEntry = this.config.modules.variantEntry;
+            const { content_type, locale, entry_uid } = entriesForVariant;
+            const ctConfig = this.config.modules['content-types'];
+            const contentType = JSON.parse((0, fs_1.readFileSync)((0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), (0, cli_utilities_1.sanitizePath)(ctConfig.dirName), `${(0, cli_utilities_1.sanitizePath)(content_type)}.json`), 'utf8'));
+            const variantEntryBasePath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.entriesDirPath), (0, cli_utilities_1.sanitizePath)(content_type), (0, cli_utilities_1.sanitizePath)(locale), (0, cli_utilities_1.sanitizePath)(variantEntry.dirName), (0, cli_utilities_1.sanitizePath)(entry_uid));
+            const fs = new cli_utilities_1.FsUtility({ basePath: variantEntryBasePath });
+            for (const _ in fs.indexFileContent) {
+                try {
+                    const variantEntries = (yield fs.readChunkFiles.next());
+                    if (variantEntries === null || variantEntries === void 0 ? void 0 : variantEntries.length) {
+                        yield this.handleConcurrency(contentType, variantEntries, entriesForVariant);
+                    }
+                }
+                catch (error) {
+                    (0, utils_1.log)(this.config, error, 'error');
+                }
+            }
+        });
+    }
+    /**
+     * The function `handleConcurrency` processes variant entries in batches with a specified concurrency
+     * level and handles API calls for creating variant entries.
+     * @param {VariantEntryStruct[]} variantEntries - The `variantEntries` parameter is an array of
+     * `VariantEntryStruct` objects. It seems like this function is handling concurrency for processing
+     * these entries in batches. The function chunks the `variantEntries` array into smaller batches and
+     * then processes each batch asynchronously using `Promise.allSettled`. It also
+     * @param {EntryDataForVariantEntries} entriesForVariant - The `entriesForVariant` parameter seems to
+     * be an object containing the following properties:
+     * @returns The `handleConcurrency` function processes variant entries in batches, creating variant
+     * entries using the `createVariantEntry` method and handling the API response using
+     * `Promise.allSettled`. The function also includes logic to handle variant IDs and delays between
+     * batch processing.
+     */
+    handleConcurrency(contentType, variantEntries, entriesForVariant) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let batchNo = 0;
+            const variantEntryConfig = this.config.modules.variantEntry;
+            const { content_type, locale, entry_uid } = entriesForVariant;
+            const entryUid = this.entriesUidMapper[entry_uid];
+            const batches = (0, chunk_1.default)(variantEntries, variantEntryConfig.apiConcurrency || 5);
+            if ((0, isEmpty_1.default)(batches))
+                return;
+            for (const [, batch] of (0, entries_1.default)(batches)) {
+                batchNo += 1;
+                const allPromise = [];
+                const start = Date.now();
+                for (let [, variantEntry] of (0, entries_1.default)(batch)) {
+                    const onSuccess = ({ response, apiData: { entryUid, variantUid }, log }) => {
+                        log(this.config, `Created entry variant: '${variantUid}' of entry uid ${entryUid}`, 'info');
+                    };
+                    const onReject = ({ error, apiData, log }) => {
+                        const { entryUid, variantUid } = apiData;
+                        this.failedVariantEntries.set(variantUid, apiData);
+                        log(this.config, `Failed to create entry variant: '${variantUid}' of entry uid ${entryUid}`, 'error');
+                        log(this.config, error, 'error');
+                    };
+                    // NOTE Find new variant Id by old Id
+                    const variant_id = this.variantIdList[variantEntry.variant_id];
+                    // NOTE Replace all the relation data UID's
+                    variantEntry = this.handleVariantEntryRelationalData(contentType, variantEntry);
+                    const changeSet = this.serializeChangeSet(variantEntry);
+                    const createVariantReq = Object.assign({ _variant: variantEntry._variant }, changeSet);
+                    if (variant_id) {
+                        const promise = this.variantInstance.createVariantEntry(createVariantReq, {
+                            locale,
+                            entry_uid: entryUid,
+                            variant_id,
+                            content_type_uid: content_type,
+                        }, {
+                            reject: onReject.bind(this),
+                            resolve: onSuccess.bind(this),
+                            variantUid: variantEntry.uid,
+                            log: utils_1.log,
+                        });
+                        allPromise.push(promise);
+                    }
+                    else {
+                        (0, utils_1.log)(this.config, this.messages.VARIANT_ID_NOT_FOUND, 'error');
+                    }
+                }
+                // NOTE Handle the API response here
+                yield Promise.allSettled(allPromise);
+                // NOTE publish all the entries
+                yield this.publishVariantEntries(batch, entryUid, content_type);
+                const end = Date.now();
+                const exeTime = end - start;
+                this.variantInstance.delay(1000 - exeTime);
+            }
+            utils_1.fsUtil.writeFile(this.failedVariantPath, this.failedVariantEntries);
+        });
+    }
+    /**
+     * Serializes the change set of a entry variant.
+     * @param variantEntry - The entry variant to serialize.
+     * @returns The serialized change set as a record.
+     */
+    serializeChangeSet(variantEntry) {
+        var _a, _b;
+        let changeSet = {};
+        if ((_b = (_a = variantEntry === null || variantEntry === void 0 ? void 0 : variantEntry._variant) === null || _a === void 0 ? void 0 : _a._change_set) === null || _b === void 0 ? void 0 : _b.length) {
+            variantEntry._variant._change_set.forEach((key) => {
+                key = key.split('.')[0];
+                if (variantEntry[key]) {
+                    changeSet[key] = variantEntry[key];
+                }
+            });
+        }
+        return changeSet;
+    }
+    /**
+     * The function `handleVariantEntryRelationalData` processes relational data for a entry variant
+     * based on the provided content type and configuration helpers.
+     * @param {ContentTypeStruct} contentType - The `contentType` parameter in the
+     * `handleVariantEntryRelationalData` function is of type `ContentTypeStruct`. It is used to define
+     * the structure of the content type being processed within the function. This parameter likely
+     * contains information about the schema and configuration of the content type.
+     * @param {VariantEntryStruct} variantEntry - The `variantEntry` parameter in the
+     * `handleVariantEntryRelationalData` function is a data structure that represents a entry variant.
+     * It is of type `VariantEntryStruct` and contains information related to a specific entry variant.
+     * This function is responsible for performing various operations on the `variantEntry`
+     * @returns The function `handleVariantEntryRelationalData` returns the `variantEntry` after
+     * performing various lookups and replacements on it based on the provided `contentType` and
+     * `config.helpers`.
+     */
+    handleVariantEntryRelationalData(contentType, variantEntry) {
+        if (this.config.helpers) {
+            const { lookUpTerms, lookupAssets, lookupExtension, lookupEntries, restoreJsonRteEntryRefs } = this.config.helpers;
+            // FIXME Not sure why do we even need lookupExtension in entries [Ref taken from entries import]
+            // Feel free to remove this flow if it's not valid
+            // NOTE Find and replace extension's UID
+            if (lookupExtension) {
+                lookupExtension(this.config, contentType.schema, this.config.preserveStackVersion, this.installedExtensions);
+            }
+            // NOTE Find and replace RTE Ref UIDs
+            variantEntry = restoreJsonRteEntryRefs(variantEntry, variantEntry, contentType.schema, {
+                uidMapper: this.entriesUidMapper,
+                mappedAssetUids: this.assetUidMapper,
+                mappedAssetUrls: this.assetUrlMapper,
+            });
+            // NOTE Find and replace Entry Ref UIDs
+            variantEntry = lookupEntries({
+                entry: variantEntry,
+                content_type: contentType,
+            }, this.entriesUidMapper, (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.entriesMapperPath), (0, cli_utilities_1.sanitizePath)(contentType.uid), (0, cli_utilities_1.sanitizePath)(variantEntry.locale)));
+            // NOTE: will remove term if term doesn't exists in taxonomy
+            // FIXME: Validate if taxonomy support available for variant entries,
+            // if not, feel free to remove this lookup flow.
+            lookUpTerms(contentType.schema, variantEntry, this.taxonomies, this.config);
+            // update file fields of entry variants to support lookup asset logic
+            this.updateFileFields(variantEntry);
+            // NOTE Find and replace asset's UID
+            variantEntry = lookupAssets({
+                entry: variantEntry,
+                content_type: contentType,
+            }, this.assetUidMapper, this.assetUrlMapper, (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.entriesDirPath), (0, cli_utilities_1.sanitizePath)(contentType.uid)), this.installedExtensions);
+        }
+        return variantEntry;
+    }
+    /**
+     * Updates the file fields of a entry variant to support lookup asset logic.
+     * Lookup asset expects file fields to be an object instead of a string. So here we are updating the file fields to be an object. Object has two keys: `uid` and `filename`. `uid` is the asset UID and `filename` is the name of the file. Used a dummy value for the filename. This is a temporary fix and will be updated in the future.
+     * @param variantEntry - The entry variant to update.
+     */
+    updateFileFields(variantEntry) {
+        var _a;
+        const setValue = (currentObj, keys) => {
+            if (!currentObj || keys.length === 0)
+                return;
+            const [firstKey, ...restKeys] = keys;
+            if (Array.isArray(currentObj)) {
+                for (const item of currentObj) {
+                    setValue(item, [firstKey, ...restKeys]);
+                }
+            }
+            else if (currentObj && typeof currentObj === 'object') {
+                if (firstKey in currentObj) {
+                    if (keys.length === 1) {
+                        currentObj[firstKey] = { uid: currentObj[firstKey], filename: 'dummy.jpeg' };
+                    }
+                    else {
+                        setValue(currentObj[firstKey], restKeys);
+                    }
+                }
+            }
+        };
+        const pathsToUpdate = (_a = variantEntry === null || variantEntry === void 0 ? void 0 : variantEntry._metadata) === null || _a === void 0 ? void 0 : _a.references.filter((ref) => ref._content_type_uid === 'sys_assets').map((ref) => ref.path);
+        if (pathsToUpdate) {
+            pathsToUpdate.forEach((path) => setValue(variantEntry, path.split('.')));
+        }
+    }
+    /**
+     * Publishes variant entries in batch for a given entry UID and content type.
+     * @param batch - An array of VariantEntryStruct objects representing the variant entries to be published.
+     * @param entryUid - The UID of the entry for which the variant entries are being published.
+     * @param content_type - The UID of the content type of the entry.
+     * @returns A Promise that resolves when all variant entries have been published.
+     */
+    publishVariantEntries(batch, entryUid, content_type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const allPromise = [];
+            for (let [, variantEntry] of (0, entries_1.default)(batch)) {
+                const variantUid = variantEntry.uid;
+                const oldVariantUid = variantEntry.variant_id || '';
+                const newVariantUid = this.variantIdList[oldVariantUid];
+                if (!newVariantUid) {
+                    (0, utils_1.log)(this.config, `${this.messages.VARIANT_ID_NOT_FOUND}. Skipping entry variant publish for ${variantUid}`, 'info');
+                    continue;
+                }
+                if (this.failedVariantEntries.has(variantUid)) {
+                    (0, utils_1.log)(this.config, `${this.messages.VARIANT_UID_NOT_FOUND}. Skipping entry variant publish for ${variantUid}`, 'info');
+                    continue;
+                }
+                if ((_a = this.environments) === null || _a === void 0 ? void 0 : _a.length) {
+                    (0, utils_1.log)(this.config, 'No environment found! Skipping entry variant publishing...', 'info');
+                    return;
+                }
+                const onSuccess = ({ response, apiData: { entryUid, variantUid }, log }) => {
+                    log(this.config, `Entry variant: '${variantUid}' of entry uid ${entryUid} published successfully!`, 'info');
+                };
+                const onReject = ({ error, apiData: { entryUid, variantUid }, log }) => {
+                    log(this.config, `Failed to publish entry variant: '${variantUid}' of entry uid ${entryUid}`, 'error');
+                    log(this.config, (0, utils_1.formatError)(error), 'error');
+                };
+                const { environments, locales } = this.serializePublishEntries(variantEntry);
+                if ((environments === null || environments === void 0 ? void 0 : environments.length) === 0 || (locales === null || locales === void 0 ? void 0 : locales.length) === 0) {
+                    continue;
+                }
+                const publishReq = {
+                    entry: {
+                        environments,
+                        locales,
+                        publish_with_base_entry: false,
+                        variants: [{ uid: newVariantUid, version: 1 }],
+                    },
+                    locale: variantEntry.locale,
+                    version: 1,
+                };
+                const promise = this.variantInstance.publishVariantEntry(publishReq, {
+                    entry_uid: entryUid,
+                    content_type_uid: content_type,
+                }, {
+                    reject: onReject.bind(this),
+                    resolve: onSuccess.bind(this),
+                    log: utils_1.log,
+                    variantUid,
+                });
+                allPromise.push(promise);
+            }
+            yield Promise.allSettled(allPromise);
+        });
+    }
+    /**
+     * Serializes the publish entries of a variant.
+     * @param variantEntry - The entry variant to serialize.
+     * @returns An object containing the serialized publish entries.
+     */
+    serializePublishEntries(variantEntry) {
+        var _a;
+        const requestObject = {
+            environments: [],
+            locales: [],
+        };
+        if (variantEntry.publish_details && ((_a = variantEntry.publish_details) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            (0, forEach_1.default)(variantEntry.publish_details, (pubObject) => {
+                if (this.environments.hasOwnProperty(pubObject.environment) &&
+                    (0, indexOf_1.default)(requestObject.environments, this.environments[pubObject.environment].name) === -1) {
+                    requestObject.environments.push(this.environments[pubObject.environment].name);
+                }
+                if (pubObject.locale && (0, indexOf_1.default)(requestObject.locales, pubObject.locale) === -1) {
+                    requestObject.locales.push(pubObject.locale);
+                }
+            });
+        }
+        return requestObject;
+    }
+}
+exports.default = VariantEntries;

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './utils';
+export * from './export';
+export * from './import';
+export * from './messages';

package/lib/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./export"), exports);
+__exportStar(require("./import"), exports);
+__exportStar(require("./messages"), exports);

package/lib/messages/index.d.ts

@@ -0,0 +1,35 @@
+declare const errors: {
+    CREATE_FAILURE: string;
+};
+declare const commonMsg: {
+    CREATE_SUCCESS: string;
+};
+declare const migrationMsg: {
+    IMPORT_MSG: string;
+};
+declare const variantEntry: {
+    IMPORT_ENTRY_NOT_FOUND: string;
+    EMPTY_VARIANT_UID_DATA: string;
+    VARIANT_ID_NOT_FOUND: string;
+    VARIANT_UID_NOT_FOUND: string;
+};
+declare const expImportMsg: {
+    UPDATING_CT_IN_EXP: string;
+    UPDATED_CT_IN_EXP: string;
+    VALIDATE_VARIANT_AND_VARIANT_GRP: string;
+    PERSONALIZATION_JOB_FAILURE: string;
+};
+declare const messages: typeof errors & typeof commonMsg & typeof migrationMsg & typeof variantEntry & typeof expImportMsg;
+/**
+ * The function `` is a TypeScript function that replaces placeholders in a message string with
+ * values from a provided object.
+ * @param {string} msg - The `msg` parameter is a string that represents the message template with
+ * placeholders for dynamic values.
+ * @param args - The `args` parameter is an object that contains key-value pairs where the key is a
+ * string and the value is also a string. These key-value pairs are used to replace placeholders in the
+ * `msg` string with the corresponding values.
+ * @returns the formatted message with the provided arguments replaced in the placeholders.
+ */
+declare function $t(msg: string, args: Record<string, string>): string;
+export default messages;
+export { $t, errors, commonMsg };

package/lib/messages/index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonMsg = exports.errors = void 0;
+exports.$t = $t;
+const memoize_1 = __importDefault(require("lodash/memoize"));
+const errors = {
+    CREATE_FAILURE: '{module} creation failed!',
+};
+exports.errors = errors;
+const commonMsg = {
+    CREATE_SUCCESS: '{module} created successfully!',
+};
+exports.commonMsg = commonMsg;
+const migrationMsg = {
+    IMPORT_MSG: 'Migrating {module}...',
+};
+const variantEntry = {
+    IMPORT_ENTRY_NOT_FOUND: 'Entries data not found to import variant entries',
+    EMPTY_VARIANT_UID_DATA: 'Empty variants entry mapper found!',
+    VARIANT_ID_NOT_FOUND: 'Variant ID not found',
+    VARIANT_UID_NOT_FOUND: 'Entry Variant UID not found',
+};
+const expImportMsg = {
+    UPDATING_CT_IN_EXP: 'Updating content types in experiences...',
+    UPDATED_CT_IN_EXP: 'Successfully updated content types in experiences!',
+    VALIDATE_VARIANT_AND_VARIANT_GRP: 'Validating variant group and variants creation...',
+    PERSONALIZATION_JOB_FAILURE: 'Something went wrong with personalization background job! Failed to fetch some variant & variant groups',
+};
+const messages = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, errors), commonMsg), migrationMsg), variantEntry), expImportMsg);
+/**
+ * The function `` is a TypeScript function that replaces placeholders in a message string with
+ * values from a provided object.
+ * @param {string} msg - The `msg` parameter is a string that represents the message template with
+ * placeholders for dynamic values.
+ * @param args - The `args` parameter is an object that contains key-value pairs where the key is a
+ * string and the value is also a string. These key-value pairs are used to replace placeholders in the
+ * `msg` string with the corresponding values.
+ * @returns the formatted message with the provided arguments replaced in the placeholders.
+ */
+function $t(msg, args) {
+    const transfer = (0, memoize_1.default)(function (msg, args) {
+        if (!msg)
+            return '';
+        for (const key of Object.keys(args)) {
+            const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            msg = msg.replace(new RegExp(`{${escapedKey}}`, 'g'), args[key] || escapedKey);
+        }
+        return msg;
+    });
+    return transfer(msg, args);
+}
+exports.default = messages;

package/lib/types/adapter-helper.d.ts

@@ -0,0 +1,8 @@
+import messages from "../messages";
+export interface AdapterHelperInterface<T, Client> {
+    readonly config: T;
+    readonly apiClient: Client;
+    readonly messages: typeof messages;
+    delay(ms: number): Promise<void>;
+    constructQuery(query: Record<string, any>): string | void;
+}

package/lib/types/adapter-helper.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/content-types.d.ts

@@ -0,0 +1,19 @@
+import { AnyProperty } from './utils';
+import { ImportConfig } from './import-config';
+export type ContentTypeStruct = {
+    uid: string;
+    title: string;
+    description: string;
+    schema: AnyProperty[];
+    options: AnyProperty;
+} & AnyProperty;
+export type ImportHelperMethodsConfig = {
+    lookupAssets: (data: Record<string, any>, mappedAssetUids: Record<string, any>, mappedAssetUrls: Record<string, any>, assetUidMapperPath: string, installedExtensions: Record<string, any>[]) => any;
+    lookupExtension?: (config: ImportConfig, schema: any, preserveStackVersion: any, installedExtensions: any) => void;
+    restoreJsonRteEntryRefs: (entry: Record<string, any>, sourceStackEntry: any, ctSchema: any, { uidMapper, mappedAssetUids, mappedAssetUrls }: any) => Record<string, any>;
+    lookupEntries: (data: {
+        content_type: any;
+        entry: any;
+    }, mappedUids: Record<string, any>, uidMapperPath: string) => any;
+    lookUpTerms: (ctSchema: Record<string, any>[], entry: any, taxonomiesAndTermData: Record<string, any>, importConfig: ImportConfig) => void;
+};