@contentstack/cli-cm-import 1.5.11 → 1.7.0

package/lib/import/modules/base-class.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const pick_1 = tslib_1.__importDefault(require("lodash/pick"));
+const last_1 = tslib_1.__importDefault(require("lodash/last"));
+const chunk_1 = tslib_1.__importDefault(require("lodash/chunk"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const entries_1 = tslib_1.__importDefault(require("lodash/entries"));
+const isEqual_1 = tslib_1.__importDefault(require("lodash/isEqual"));
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const utils_1 = require("../../utils");
+class BaseClass {
+    constructor({ importConfig, stackAPIClient }) {
+        this.client = stackAPIClient;
+        this.importConfig = importConfig;
+        this.modulesConfig = importConfig.modules;
+    }
+    get stack() {
+        return this.client;
+    }
+    /**
+     * @method delay
+     * @param {number} ms number
+     * @returns {Promise} Promise<void>
+     */
+    delay(ms) {
+        /* eslint-disable no-promise-executor-return */
+        return new Promise((resolve) => setTimeout(resolve, ms <= 0 ? 0 : ms));
+    }
+    /**
+     * @method makeConcurrentCall
+     * @param {Record<string, any>} env EnvType
+     * @param {CustomPromiseHandler} promisifyHandler CustomPromiseHandler
+     * @param {boolean} logBatchCompletionMsg boolean
+     * @returns {Promise} Promise<void>
+     */
+    makeConcurrentCall(env, promisifyHandler, logBatchCompletionMsg = true) {
+        const { apiParams, apiContent, processName, indexerCount, currentIndexer, concurrencyLimit = this.importConfig.modules.apiConcurrency, } = env;
+        /* eslint-disable no-async-promise-executor */
+        return new Promise(async (resolve) => {
+            let batchNo = 0;
+            let isLastRequest = false;
+            const batches = (0, chunk_1.default)(apiContent, concurrencyLimit);
+            /* eslint-disable no-promise-executor-return */
+            if ((0, isEmpty_1.default)(batches))
+                return resolve();
+            for (const [batchIndex, batch] of (0, entries_1.default)(batches)) {
+                batchNo += 1;
+                const allPromise = [];
+                const start = Date.now();
+                for (const [index, element] of (0, entries_1.default)(batch)) {
+                    let promise = Promise.resolve();
+                    isLastRequest = (0, isEqual_1.default)((0, last_1.default)(batch), element) && (0, isEqual_1.default)((0, last_1.default)(batches), batch);
+                    if (promisifyHandler instanceof Function) {
+                        promise = promisifyHandler({
+                            apiParams,
+                            isLastRequest,
+                            element,
+                            index: Number(index),
+                            batchIndex: Number(batchIndex),
+                        });
+                    }
+                    else if (apiParams) {
+                        apiParams.apiData = element;
+                        promise = this.makeAPICall(apiParams, isLastRequest);
+                    }
+                    allPromise.push(promise);
+                }
+                /* eslint-disable no-await-in-loop */
+                await Promise.allSettled(allPromise);
+                /* eslint-disable no-await-in-loop */
+                await this.logMsgAndWaitIfRequired(processName, start, batches.length, batchNo, logBatchCompletionMsg, indexerCount, currentIndexer);
+                if (isLastRequest)
+                    resolve();
+            }
+        });
+    }
+    /**
+     * @method logMsgAndWaitIfRequired
+     * @param {string} processName string
+     * @param {number} start number
+     * @param {number} batchNo - number
+     * @returns {Promise} Promise<void>
+     */
+    async logMsgAndWaitIfRequired(processName, start, totelBatches, batchNo, logBatchCompletionMsg = true, indexerCount, currentIndexer) {
+        const end = Date.now();
+        const exeTime = end - start;
+        if (logBatchCompletionMsg) {
+            let batchMsg = '';
+            // info: Batch No. 20 of import assets is complete
+            if (currentIndexer)
+                batchMsg += `Current chunk processing is (${currentIndexer}/${indexerCount})`;
+            (0, utils_1.log)(this.importConfig, `Batch No. (${batchNo}/${totelBatches}) of ${processName} is complete. ${batchMsg}`, 'success');
+        }
+        if (this.importConfig.modules.assets.displayExecutionTime) {
+            console.log(`Time taken to execute: ${exeTime} milliseconds; wait time: ${exeTime < 1000 ? 1000 - exeTime : 0} milliseconds`);
+        }
+        if (exeTime < 1000)
+            await this.delay(1000 - exeTime);
+    }
+    /**
+     * @method makeAPICall
+     * @param {Record<string, any>} apiOptions - Api related params
+     * @param {Record<string, any>} isLastRequest - Boolean
+     * @return {Promise} Promise<void>
+     */
+    makeAPICall(apiOptions, isLastRequest = false) {
+        if (apiOptions.serializeData instanceof Function) {
+            apiOptions = apiOptions.serializeData(apiOptions);
+        }
+        const { uid, entity, reject, resolve, apiData, additionalInfo, includeParamOnCompletion } = apiOptions;
+        const onSuccess = (response) => resolve({
+            response,
+            isLastRequest,
+            additionalInfo,
+            apiData: includeParamOnCompletion ? apiData : undefined,
+        });
+        const onReject = (error) => reject({
+            error,
+            isLastRequest,
+            additionalInfo,
+            apiData: includeParamOnCompletion ? apiData : undefined,
+        });
+        switch (entity) {
+            case 'create-assets-folder':
+                return this.stack
+                    .asset()
+                    .folder()
+                    .create({ asset: (0, pick_1.default)(apiData, this.modulesConfig.assets.folderValidKeys) })
+                    .then(onSuccess)
+                    .catch(onReject);
+            case 'create-assets':
+                return this.stack
+                    .asset()
+                    .create((0, pick_1.default)(apiData, [...this.modulesConfig.assets.validKeys, 'upload']))
+                    .then(onSuccess)
+                    .catch(onReject);
+            case 'replace-assets':
+                return this.stack
+                    .asset(uid)
+                    .replace((0, pick_1.default)(apiData, [...this.modulesConfig.assets.validKeys, 'upload']))
+                    .then(onSuccess)
+                    .catch(onReject);
+            case 'publish-assets':
+                return this.stack
+                    .asset(uid)
+                    .publish((0, pick_1.default)(apiData, ['publishDetails']))
+                    .then(onSuccess)
+                    .catch(onReject);
+            case 'create-extensions':
+                return this.stack
+                    .extension()
+                    .create({ extension: (0, omit_1.default)(apiData, ['uid']) })
+                    .then(onSuccess)
+                    .catch(onReject);
+            case 'create-locale':
+                return this.stack
+                    .locale()
+                    .create({ locale: (0, pick_1.default)(apiData, ['name', 'code']) })
+                    .then(onSuccess)
+                    .catch(onReject);
+            case 'update-locale':
+                return this.stack
+                    .locale(apiData.code)
+                    .update({ locale: (0, pick_1.default)(apiData, [...this.modulesConfig.locales.requiredKeys]) })
+                    .then(onSuccess)
+                    .catch(onReject);
+            case 'create-cts':
+                return this.stack.contentType().create(apiData).then(onSuccess).catch(onReject);
+            case 'update-cts':
+                return apiData.update().then(onSuccess).catch(onReject);
+            case 'update-gfs':
+                return apiData.update().then(onSuccess).catch(onReject);
+            case 'create-environments':
+            // return this.stack
+            //   .environment()
+            //   .create({ environment: omit(apiData, ['uid']) as EnvironmentData })
+            //   .then(onSuccess)
+            //   .catch(onReject);
+            case 'create-labels':
+                return this.stack
+                    .label()
+                    .create({ label: (0, omit_1.default)(apiData, ['uid']) })
+                    .then(onSuccess)
+                    .catch(onReject);
+            case 'update-labels':
+                return this.stack
+                    .label(apiData.uid)
+                    .fetch()
+                    .then(async (response) => {
+                    response.parent = apiData.parent;
+                    await response.update().then(onSuccess).catch(onReject);
+                })
+                    .catch(onReject);
+            case 'create-webhooks':
+                return this.stack
+                    .webhook()
+                    .create({ webhook: (0, omit_1.default)(apiData, ['uid']) })
+                    .then(onSuccess)
+                    .catch(onReject);
+            case 'create-workflows':
+                return this.stack
+                    .workflow()
+                    .create({ workflow: apiData })
+                    .then(onSuccess)
+                    .catch(onReject);
+            case 'create-custom-role':
+                return this.stack
+                    .role()
+                    .create({ role: apiData })
+                    .then(onSuccess)
+                    .catch(onReject);
+            default:
+                return Promise.resolve();
+        }
+    }
+}
+exports.default = BaseClass;

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

@@ -0,0 +1,56 @@
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+import { ModuleClassParams } from '../../types';
+import BaseClass, { ApiOptions } from './base-class';
+export default class ContentTypesImport extends BaseClass {
+    private cTsMapperPath;
+    private cTsFolderPath;
+    private cTsFailsPath;
+    private cTsSuccessPath;
+    private gFsPendingPath;
+    private pendingGFs;
+    private createdGFs;
+    private gFsFolderPath;
+    private gFsMapperFolderPath;
+    private gFs;
+    private failedCTs;
+    private createdCTs;
+    private cTs;
+    private cTsUidMapper;
+    private config;
+    private stackAPIClient;
+    private marketplaceAppMapperPath;
+    private reqConcurrency;
+    private ignoredFilesInContentTypesFolder;
+    private titleToUIdMap;
+    private fieldRules;
+    private installedExtensions;
+    private cTsConfig;
+    private gFsConfig;
+    constructor({ importConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<any>;
+    seedCTs(): Promise<any>;
+    /**
+     * @method serializeCTs
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeCTs(apiOptions: ApiOptions): ApiOptions;
+    updateCTs(): Promise<any>;
+    /**
+     * @method serializeUpdateCTs
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeUpdateCTs(apiOptions: ApiOptions): ApiOptions;
+    updatePendingGFs(): Promise<any>;
+    /**
+     * @method serializeUpdateGFs
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeUpdateGFs(apiOptions: ApiOptions): ApiOptions;
+}

package/lib/import/modules/content-types.js

@@ -0,0 +1,186 @@
+"use strict";
+/* eslint-disable no-prototype-builtins */
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const lodash_1 = require("lodash");
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class ContentTypesImport extends base_class_1.default {
+    constructor({ importConfig, stackAPIClient }) {
+        super({ importConfig, stackAPIClient });
+        this.cTsConfig = importConfig.modules['content-types'];
+        this.gFsConfig = importConfig.modules['global-fields'];
+        this.reqConcurrency = this.cTsConfig.writeConcurrency || this.importConfig.writeConcurrency;
+        this.cTsFolderPath = path.join(this.importConfig.data, this.cTsConfig.dirName);
+        this.cTsMapperPath = path.join(this.importConfig.data, 'mapper', 'content_types');
+        this.cTsSuccessPath = path.join(this.cTsMapperPath, 'success.json');
+        this.gFsFolderPath = path.resolve(this.importConfig.data, this.gFsConfig.dirName);
+        this.gFsMapperFolderPath = path.join(importConfig.data, 'mapper', 'global_fields', 'success.json');
+        this.gFsPendingPath = path.join(importConfig.data, 'mapper', 'global_fields', 'pending_global_fields.js');
+        this.marketplaceAppMapperPath = path.join(this.importConfig.data, 'mapper', 'marketplace_apps', 'uid-mapping.json');
+        this.ignoredFilesInContentTypesFolder = new Map([
+            ['__master.json', 'true'],
+            ['__priority.json', 'true'],
+            ['schema.json', 'true'],
+            ['.DS_Store', 'true'],
+        ]);
+        this.cTs = [];
+        this.createdCTs = [];
+        this.titleToUIdMap = new Map();
+        this.fieldRules = [];
+        this.gFs = [];
+        this.createdGFs = [];
+        this.pendingGFs = [];
+    }
+    async start() {
+        /**
+         * read content type, check if it is necessary to read the entire dir
+         * Seed content types
+         * Update content types, lookup extension.
+         * Update pending global fields
+         * write field rules
+         */
+        this.cTs = utils_1.fsUtil.readFile(path.join(this.cTsFolderPath, 'schema.json'));
+        if (!this.cTs || (0, lodash_1.isEmpty)(this.cTs)) {
+            (0, utils_1.log)(this.importConfig, 'No content type found to import', 'info');
+            return;
+        }
+        await utils_1.fsUtil.makeDirectory(this.cTsMapperPath);
+        this.installedExtensions = ((await utils_1.fsUtil.readFile(this.marketplaceAppMapperPath)) || { extension_uid: {} }).extension_uid;
+        await this.seedCTs();
+        (0, utils_1.log)(this.importConfig, 'Created content types', 'success');
+        await this.updateCTs();
+        (0, utils_1.log)(this.importConfig, 'Updated content types with references', 'success');
+        if (this.fieldRules.length > 0) {
+            await utils_1.fsUtil.writeFile(path.join(this.cTsFolderPath, 'field_rules_uid.json'), this.fieldRules);
+        }
+        await this.updatePendingGFs().catch((error) => {
+            (0, utils_1.log)(this.importConfig, `Error while updating pending global field ${(0, utils_1.formatError)(error)}`, 'error');
+        });
+        (0, utils_1.log)(this.importConfig, 'Updated pending global fields with content type with references', 'success');
+        (0, utils_1.log)(this.importConfig, 'Content types have been imported successfully!', 'success');
+    }
+    async seedCTs() {
+        const onSuccess = ({ response: globalField, apiData: { content_type: { uid = null } = {} } = {} }) => {
+            (0, utils_1.log)(this.importConfig, `${uid} content type seeded`, 'info');
+        };
+        const onReject = ({ error, apiData: { content_type: { uid = null } = {} } = {} }) => {
+            if (error.errorCode === 115 && (error.errors.uid || error.errors.title)) {
+                (0, utils_1.log)(this.importConfig, `${uid} content type already exist`, 'info');
+            }
+            else {
+                (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+                process.exit(1);
+            }
+        };
+        return await this.makeConcurrentCall({
+            processName: 'Import content types',
+            apiContent: this.cTs,
+            apiParams: {
+                serializeData: this.serializeCTs.bind(this),
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'create-cts',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: this.reqConcurrency,
+        });
+    }
+    /**
+     * @method serializeCTs
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeCTs(apiOptions) {
+        const { apiData: contentType } = apiOptions;
+        const updatedCT = (0, lodash_1.cloneDeep)(utils_1.schemaTemplate);
+        updatedCT.content_type.uid = contentType.uid;
+        updatedCT.content_type.title = contentType.title;
+        apiOptions.apiData = updatedCT;
+        return apiOptions;
+    }
+    async updateCTs() {
+        const onSuccess = ({ response: contentType, apiData: { uid } }) => {
+            (0, utils_1.log)(this.importConfig, `${uid} updated with references`, 'success');
+        };
+        const onReject = ({ error, apiData: { uid } }) => {
+            (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            throw new Error(`Content type '${uid}' update error`);
+        };
+        return await this.makeConcurrentCall({
+            processName: 'Update content types',
+            apiContent: this.cTs,
+            apiParams: {
+                serializeData: this.serializeUpdateCTs.bind(this),
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'update-cts',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: this.reqConcurrency,
+        });
+    }
+    /**
+     * @method serializeUpdateCTs
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeUpdateCTs(apiOptions) {
+        const { apiData: contentType } = apiOptions;
+        if (contentType.field_rules) {
+            this.fieldRules.push(contentType.uid);
+            delete contentType.field_rules;
+        }
+        (0, utils_1.lookupExtension)(this.importConfig, contentType.schema, this.importConfig.preserveStackVersion, this.installedExtensions);
+        const contentTypePayload = this.stack.contentType(contentType.uid);
+        Object.assign(contentTypePayload, (0, lodash_1.cloneDeep)(contentType));
+        apiOptions.apiData = contentTypePayload;
+        return apiOptions;
+    }
+    async updatePendingGFs() {
+        this.pendingGFs = utils_1.fsUtil.readFile(this.gFsPendingPath);
+        this.gFs = utils_1.fsUtil.readFile(path.resolve(this.gFsFolderPath, this.gFsConfig.fileName));
+        const onSuccess = ({ response: globalField, apiData: { uid } = undefined }) => {
+            (0, utils_1.log)(this.importConfig, `Updated the global field ${uid} with content type references`, 'info');
+        };
+        const onReject = ({ error, apiData: { uid } = undefined }) => {
+            (0, utils_1.log)(this.importConfig, `failed to update the global field ${uid} ${(0, utils_1.formatError)(error)}`, 'error');
+        };
+        return await this.makeConcurrentCall({
+            processName: 'Update pending global fields',
+            apiContent: (0, lodash_1.map)(this.pendingGFs, (uid) => {
+                return { uid };
+            }),
+            apiParams: {
+                serializeData: this.serializeUpdateGFs.bind(this),
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'update-gfs',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: this.reqConcurrency,
+        });
+    }
+    /**
+     * @method serializeUpdateGFs
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeUpdateGFs(apiOptions) {
+        const { apiData: { uid }, } = apiOptions;
+        const globalField = (0, lodash_1.find)(this.gFs, { uid });
+        (0, utils_1.lookupExtension)(this.importConfig, globalField.schema, this.importConfig.preserveStackVersion, this.installedExtensions);
+        apiOptions.apiData = globalField;
+        const globalFieldPayload = this.stack.globalField(uid);
+        Object.assign(globalFieldPayload, (0, lodash_1.cloneDeep)(globalField));
+        apiOptions.apiData = globalFieldPayload;
+        return apiOptions;
+    }
+}
+exports.default = ContentTypesImport;

package/lib/import/modules/custom-roles.d.ts

@@ -0,0 +1,37 @@
+import BaseClass, { ApiOptions } from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class ImportCustomRoles extends BaseClass {
+    private customRolesMapperPath;
+    private customRolesFolderPath;
+    private customRolesUidMapperPath;
+    private envUidMapperFolderPath;
+    private entriesUidMapperFolderPath;
+    private createdCustomRolesPath;
+    private customRolesFailsPath;
+    private customRolesConfig;
+    private customRoles;
+    private customRolesLocales;
+    private customRolesUidMapper;
+    private createdCustomRoles;
+    private failedCustomRoles;
+    private environmentsUidMap;
+    private entriesUidMap;
+    private localesUidMap;
+    targetLocalesMap: Record<string, unknown>;
+    sourceLocalesMap: Record<string, unknown>;
+    constructor({ importConfig, stackAPIClient }: ModuleClassParams);
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    start(): Promise<void>;
+    getLocalesUidMap(): Promise<void>;
+    importCustomRoles(): Promise<string>;
+    /**
+     * @method serializeWebhooks
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeWebhooks(apiOptions: ApiOptions): ApiOptions;
+    getTransformUidsFactory: (rule: Record<string, any>) => Record<string, any>;
+}

package/lib/import/modules/custom-roles.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const values_1 = tslib_1.__importDefault(require("lodash/values"));
+const node_path_1 = require("node:path");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+const lodash_1 = require("lodash");
+class ImportCustomRoles extends base_class_1.default {
+    constructor({ importConfig, stackAPIClient }) {
+        super({ importConfig, stackAPIClient });
+        this.getTransformUidsFactory = (rule) => {
+            if (rule.module === 'environment') {
+                rule.environments = (0, lodash_1.map)(rule.environments, (env) => this.environmentsUidMap[env]);
+            }
+            else if (rule.module === 'locale') {
+                rule.locales = (0, lodash_1.map)(rule.locales, (locale) => this.localesUidMap[locale]);
+            }
+            else if (rule.module === 'entry') {
+                rule.entries = (0, lodash_1.map)(rule.entries, (entry) => this.entriesUidMap[entry]);
+            }
+            return rule;
+        };
+        this.customRolesConfig = config_1.default.modules.customRoles;
+        this.customRolesMapperPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'custom-roles');
+        this.customRolesFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, this.customRolesConfig.dirName);
+        this.customRolesUidMapperPath = (0, node_path_1.join)(this.customRolesMapperPath, 'uid-mapping.json');
+        this.envUidMapperFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'environments');
+        this.entriesUidMapperFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'entries');
+        this.createdCustomRolesPath = (0, node_path_1.join)(this.customRolesMapperPath, 'success.json');
+        this.customRolesFailsPath = (0, node_path_1.join)(this.customRolesMapperPath, 'fails.json');
+        this.customRoles = {};
+        this.failedCustomRoles = [];
+        this.createdCustomRoles = [];
+        this.customRolesUidMapper = {};
+        this.customRolesLocales = {};
+        this.environmentsUidMap = {};
+        this.entriesUidMap = {};
+        this.localesUidMap = {};
+    }
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    async start() {
+        var _a, _b;
+        (0, utils_1.log)(this.importConfig, 'Migrating custom-roles', 'info');
+        //Step1 check folder exists or not
+        if (utils_1.fileHelper.fileExistsSync(this.customRolesFolderPath)) {
+            this.customRoles = utils_1.fsUtil.readFile((0, node_path_1.join)(this.customRolesFolderPath, this.customRolesConfig.fileName), true);
+            this.customRolesLocales = utils_1.fsUtil.readFile((0, node_path_1.join)(this.customRolesFolderPath, this.customRolesConfig.customRolesLocalesFileName), true);
+        }
+        else {
+            (0, utils_1.log)(this.importConfig, `No such file or directory - '${this.customRolesFolderPath}'`, 'error');
+            return;
+        }
+        //create webhooks in mapper directory
+        await utils_1.fsUtil.makeDirectory(this.customRolesMapperPath);
+        this.customRolesUidMapper = utils_1.fileHelper.fileExistsSync(this.customRolesUidMapperPath)
+            ? utils_1.fsUtil.readFile((0, node_path_1.join)(this.customRolesUidMapperPath), true)
+            : {};
+        this.environmentsUidMap = utils_1.fileHelper.fileExistsSync(this.envUidMapperFolderPath)
+            ? utils_1.fsUtil.readFile((0, node_path_1.join)(this.envUidMapperFolderPath, 'uid-mapping.json'), true)
+            : {};
+        this.entriesUidMap = utils_1.fileHelper.fileExistsSync(this.entriesUidMapperFolderPath)
+            ? utils_1.fsUtil.readFile((0, node_path_1.join)(this.entriesUidMapperFolderPath, 'uid-mapping.json'), true)
+            : {};
+        //source and target stack locale map
+        await this.getLocalesUidMap();
+        await this.importCustomRoles();
+        if ((_a = this.createdCustomRoles) === null || _a === void 0 ? void 0 : _a.length) {
+            utils_1.fsUtil.writeFile(this.createdCustomRolesPath, this.createdCustomRoles);
+        }
+        if ((_b = this.failedCustomRoles) === null || _b === void 0 ? void 0 : _b.length) {
+            utils_1.fsUtil.writeFile(this.customRolesFailsPath, this.failedCustomRoles);
+        }
+        (0, utils_1.log)(this.importConfig, 'Custom roles have been imported successfully!', 'success');
+    }
+    async getLocalesUidMap() {
+        const { items } = await this.stack
+            .locale()
+            .query()
+            .find()
+            .then((data) => data)
+            .catch((error) => (0, utils_1.log)(this.importConfig, `Failed to fetch locale.${(0, utils_1.formatError)(error)}`, 'error'));
+        this.targetLocalesMap = {};
+        this.sourceLocalesMap = {};
+        (0, lodash_1.forEach)(items, (locale) => {
+            this.targetLocalesMap[locale.code] = locale.uid;
+        });
+        for (const key in this.customRolesLocales) {
+            const sourceLocales = this.customRolesLocales[key];
+            this.sourceLocalesMap[sourceLocales.code] = key;
+        }
+        for (const key in this.sourceLocalesMap) {
+            const sourceLocaleKey = this.sourceLocalesMap[key];
+            this.localesUidMap[sourceLocaleKey] = this.targetLocalesMap[key];
+        }
+    }
+    async importCustomRoles() {
+        if (this.customRoles === undefined || (0, isEmpty_1.default)(this.customRoles)) {
+            (0, utils_1.log)(this.importConfig, 'No custom-roles found', 'info');
+            return (0, node_path_1.resolve)();
+        }
+        const apiContent = (0, values_1.default)(this.customRoles);
+        const onSuccess = ({ response, apiData: { uid, name } = { uid: null, name: '' } }) => {
+            this.createdCustomRoles.push(response);
+            this.customRolesUidMapper[uid] = response.uid;
+            (0, utils_1.log)(this.importConfig, `custom-role '${name}' imported successfully`, 'success');
+            utils_1.fsUtil.writeFile(this.customRolesUidMapperPath, this.customRolesUidMapper);
+        };
+        const onReject = ({ error, apiData }) => {
+            var _a;
+            const err = (error === null || error === void 0 ? void 0 : error.message) ? JSON.parse(error.message) : error;
+            const { name } = apiData;
+            if ((_a = err === null || err === void 0 ? void 0 : err.errors) === null || _a === void 0 ? void 0 : _a.name) {
+                (0, utils_1.log)(this.importConfig, `custom-role '${name}' already exists`, 'info');
+            }
+            else {
+                this.failedCustomRoles.push(apiData);
+                (0, utils_1.log)(this.importConfig, `custom-role '${name}' failed to be import.${(0, utils_1.formatError)(error)}`, 'error');
+                (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            }
+        };
+        await this.makeConcurrentCall({
+            apiContent,
+            processName: 'create custom role',
+            apiParams: {
+                serializeData: this.serializeWebhooks.bind(this),
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'create-custom-role',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: config_1.default.fetchConcurrency || 1,
+        }, undefined, false);
+    }
+    /**
+     * @method serializeWebhooks
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeWebhooks(apiOptions) {
+        const { apiData: customRole } = apiOptions;
+        if (this.customRolesUidMapper.hasOwnProperty(customRole.uid)) {
+            (0, utils_1.log)(this.importConfig, `custom-role '${customRole.name}' already exists. Skipping it to avoid duplicates!`, 'info');
+            apiOptions.entity = undefined;
+        }
+        else {
+            let branchRuleExists = false;
+            (0, lodash_1.forEach)(customRole.rules, (rule) => {
+                rule = this.getTransformUidsFactory(rule);
+                // rules.branch is required to create custom roles.
+                if (rule.module === 'branch')
+                    branchRuleExists = true;
+            });
+            if (!branchRuleExists) {
+                customRole.rules.push({
+                    module: 'branch',
+                    branches: ['main'],
+                    acl: { read: true },
+                });
+            }
+            apiOptions.apiData = customRole;
+        }
+        return apiOptions;
+    }
+}
+exports.default = ImportCustomRoles;