@contentstack/cli-cm-import-setup 1.0.0-beta.1

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

@@ -0,0 +1,183 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const lodash_1 = require("lodash");
+class BaseImportSetup {
+    constructor({ config, stackAPIClient, dependencies }) {
+        this.config = config;
+        this.stackAPIClient = stackAPIClient;
+        this.dependencies = dependencies;
+    }
+    async setupDependencies() {
+        var _a;
+        for (const moduleName of this.dependencies) {
+            try {
+                const modulePath = `./${moduleName}`;
+                const { default: ModuleClass } = await (_a = modulePath, Promise.resolve().then(() => __importStar(require(_a))));
+                const modulePayload = {
+                    config: this.config,
+                    stackAPIClient: this.stackAPIClient,
+                };
+                const moduleInstance = new ModuleClass(modulePayload);
+                await moduleInstance.start();
+            }
+            catch (error) {
+                (0, utils_1.log)(this.config, `Error importing '${moduleName}': ${error.message}`, 'error');
+            }
+        }
+    }
+    /**
+     * @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.config.fetchConcurrency, } = env;
+        /* eslint-disable no-async-promise-executor */
+        return new Promise(async (resolve) => {
+            let batchNo = 0;
+            let isLastRequest = false;
+            const batches = (0, lodash_1.chunk)(apiContent, concurrencyLimit);
+            /* eslint-disable no-promise-executor-return */
+            if ((0, lodash_1.isEmpty)(batches))
+                return resolve();
+            for (const [batchIndex, batch] of (0, lodash_1.entries)(batches)) {
+                batchNo += 1;
+                const allPromise = [];
+                const start = Date.now();
+                for (const [index, element] of (0, lodash_1.entries)(batch)) {
+                    let promise = Promise.resolve();
+                    isLastRequest = (0, lodash_1.isEqual)((0, lodash_1.last)(batch), element) && (0, lodash_1.isEqual)((0, lodash_1.last)(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.config, `Batch No. (${batchNo}/${totelBatches}) of ${processName} is complete`, 'success');
+        }
+        // if (this.config.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,
+        });
+        if (!apiData) {
+            return Promise.resolve();
+        }
+        switch (entity) {
+            case 'fetch-assets':
+                return this.stackAPIClient
+                    .asset()
+                    .query({
+                    query: {
+                        $and: [
+                            { file_size: Number(apiData.file_size) },
+                            { filename: apiData.filename },
+                            { title: apiData.title },
+                        ],
+                    },
+                })
+                    .find()
+                    .then(onSuccess)
+                    .catch(onReject);
+            default:
+                return Promise.resolve();
+        }
+    }
+}
+exports.default = BaseImportSetup;

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

@@ -0,0 +1,6 @@
+import { ModuleClassParams } from '../../types';
+import BaseImportSetup from './base-setup';
+export default class ContentTypesImportSetup extends BaseImportSetup {
+    constructor(options: ModuleClassParams);
+    start(): Promise<void>;
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const utils_1 = require("../../utils");
+const base_setup_1 = tslib_1.__importDefault(require("./base-setup"));
+class ContentTypesImportSetup extends base_setup_1.default {
+    constructor(options) {
+        super(options);
+    }
+    async start() {
+        try {
+            await this.setupDependencies();
+            (0, utils_1.log)(this.config, `Generate required setup files for content types`, 'success');
+        }
+        catch (error) {
+            (0, utils_1.log)(this.config, `Error generating ${error.message}`, 'error');
+        }
+    }
+}
+exports.default = ContentTypesImportSetup;

package/lib/import/modules/entries.d.ts

@@ -0,0 +1,6 @@
+import { ModuleClassParams } from '../../types';
+import BaseImportSetup from './base-setup';
+export default class EntriesImportSetup extends BaseImportSetup {
+    constructor(options: ModuleClassParams);
+    start(): Promise<void>;
+}

package/lib/import/modules/entries.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const utils_1 = require("../../utils");
+const base_setup_1 = tslib_1.__importDefault(require("./base-setup"));
+class EntriesImportSetup extends base_setup_1.default {
+    constructor(options) {
+        super(options);
+    }
+    async start() {
+        try {
+            await this.setupDependencies();
+            (0, utils_1.log)(this.config, `Generate required setup files for entries`, 'success');
+        }
+        catch (error) {
+            (0, utils_1.log)(this.config, `Error generating ${error.message}`, 'error');
+        }
+    }
+}
+exports.default = EntriesImportSetup;

package/lib/import/modules/extensions.d.ts

@@ -0,0 +1,20 @@
+import { ModuleClassParams } from '../../types';
+export default class ExtensionImportSetup {
+    private config;
+    private extensionsFilePath;
+    private extensionMapper;
+    private stackAPIClient;
+    private dependencies;
+    private extensionsConfig;
+    private mapperDirPath;
+    private extensionsFolderPath;
+    private extUidMapperPath;
+    constructor({ config, stackAPIClient }: ModuleClassParams);
+    /**
+     * Start the extension import setup
+     * This method reads the extensions from the content folder and generates a mapper file
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+    getExtension(extension: any): Promise<unknown>;
+}

package/lib/import/modules/extensions.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const path_1 = require("path");
+const lodash_1 = require("lodash");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+class ExtensionImportSetup {
+    constructor({ config, stackAPIClient }) {
+        this.config = config;
+        this.stackAPIClient = stackAPIClient;
+        this.extensionsFilePath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.contentDir), 'extensions', 'extensions.json');
+        this.extensionsConfig = config.modules.extensions;
+        this.extUidMapperPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'extensions', 'uid-mapping.json');
+        this.extensionMapper = {};
+    }
+    /**
+     * Start the extension import setup
+     * This method reads the extensions from the content folder and generates a mapper file
+     * @returns {Promise<void>}
+     */
+    async start() {
+        try {
+            const extensions = await utils_1.fsUtil.readFile(this.extensionsFilePath);
+            if (!(0, lodash_1.isEmpty)(extensions)) {
+                // 2. Create mapper directory
+                const mapperFilePath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'extensions');
+                utils_1.fsUtil.makeDirectory(mapperFilePath); // Use fsUtil
+                for (const extension of Object.values(extensions)) {
+                    const targetExtension = await this.getExtension(extension);
+                    if (!targetExtension) {
+                        (0, utils_1.log)(this.config, `Extension with title '${extension.title}' not found in the stack!`, 'info');
+                        continue;
+                    }
+                    this.extensionMapper[extension.uid] = targetExtension.uid;
+                }
+                await utils_1.fsUtil.writeFile(this.extUidMapperPath, this.extensionMapper);
+                (0, utils_1.log)(this.config, `Generated required setup files for extension`, 'success');
+            }
+            else {
+                (0, utils_1.log)(this.config, 'No extensions found in the content folder!', 'error');
+            }
+        }
+        catch (error) {
+            (0, utils_1.log)(this.config, `Error generating extension mapper: ${(0, cli_utilities_1.formatError)(error)}`, 'error');
+        }
+    }
+    async getExtension(extension) {
+        // Implement this method to get the extension from the stack
+        return new Promise(async (resolve, reject) => {
+            const { items: [extensionsInStack] = [] } = (await this.stackAPIClient
+                .extension()
+                .query({ query: { title: extension.title } })
+                .findOne()
+                .catch((error) => {
+                reject(error);
+            })) || {};
+            resolve(extensionsInStack);
+        });
+    }
+}
+exports.default = ExtensionImportSetup;

package/lib/import/modules/marketplace-apps.d.ts

@@ -0,0 +1,26 @@
+import { ModuleClassParams } from '../../types';
+import { ContentstackMarketplaceClient, NodeCrypto } from '@contentstack/cli-utilities';
+export default class marketplaceAppImportSetup {
+    private config;
+    private marketplaceAppsFilePath;
+    private marketplaceAppMapper;
+    private stackAPIClient;
+    private dependencies;
+    private marketplaceAppsConfig;
+    private mapperDirPath;
+    private marketplaceAppsFolderPath;
+    private marketplaceAppsUidMapperPath;
+    developerHubBaseUrl: string;
+    marketplaceAppPath: string;
+    nodeCrypto: NodeCrypto;
+    appSdk: ContentstackMarketplaceClient;
+    constructor({ config, stackAPIClient }: ModuleClassParams);
+    /**
+     * Start the marketplaceApp import setup
+     * This method reads the marketplaceApps from the content folder and generates a mapper file
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+    getMarketplaceApps(): Promise<unknown>;
+    createMapper(sourceMarketplaceApps: any, targetMarketplaceApps: any): void;
+}

package/lib/import/modules/marketplace-apps.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const path_1 = require("path");
+const lodash_1 = require("lodash");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+class marketplaceAppImportSetup {
+    constructor({ config, stackAPIClient }) {
+        this.config = config;
+        this.stackAPIClient = stackAPIClient;
+        this.marketplaceAppsFilePath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.contentDir), 'marketplace_apps', 'marketplace_apps.json');
+        this.marketplaceAppsConfig = config.modules['marketplace-apps'];
+        this.marketplaceAppsUidMapperPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'marketplace_apps');
+        this.marketplaceAppMapper = { app_uid: {}, installation_uid: {}, extension_uid: {} };
+    }
+    /**
+     * Start the marketplaceApp import setup
+     * This method reads the marketplaceApps from the content folder and generates a mapper file
+     * @returns {Promise<void>}
+     */
+    async start() {
+        try {
+            const sourceMarketplaceApps = await utils_1.fsUtil.readFile(this.marketplaceAppsFilePath);
+            if (!(0, lodash_1.isEmpty)(sourceMarketplaceApps)) {
+                utils_1.fsUtil.makeDirectory(this.marketplaceAppsUidMapperPath); // Use fsUtil
+                this.developerHubBaseUrl = this.config.developerHubBaseUrl || (await (0, cli_utilities_1.createDeveloperHubUrl)(this.config.host));
+                // NOTE init marketplace app sdk
+                const host = this.developerHubBaseUrl.split('://').pop();
+                this.appSdk = await (0, cli_utilities_1.marketplaceSDKClient)({ host });
+                const targetMarketplaceApps = await this.getMarketplaceApps();
+                this.createMapper(sourceMarketplaceApps, targetMarketplaceApps);
+                await utils_1.fsUtil.writeFile((0, path_1.join)(this.marketplaceAppsUidMapperPath, 'uid-mapping.json'), this.marketplaceAppMapper);
+                (0, utils_1.log)(this.config, `Generated required setup files for marketplaceApp`, 'success');
+            }
+            else {
+                (0, utils_1.log)(this.config, 'No marketplaceApps found in the content folder!', 'info');
+            }
+        }
+        catch (error) {
+            (0, utils_1.log)(this.config, `Error generating marketplaceApp mapper: ${(0, cli_utilities_1.formatError)(error)}`, 'error');
+        }
+    }
+    async getMarketplaceApps() {
+        // Implement this method to get the marketplaceApp from the stack
+        return new Promise(async (resolve, reject) => {
+            const { items: marketplaceApps = [] } = (await this.appSdk
+                .marketplace(this.config.org_uid)
+                .installation()
+                .fetchAll({ target_uids: this.config.apiKey })
+                .catch((error) => {
+                reject(error);
+            })) || {};
+            resolve(marketplaceApps);
+        });
+    }
+    createMapper(sourceMarketplaceApps, targetMarketplaceApps) {
+        sourceMarketplaceApps.forEach((sourceApp) => {
+            // Find matching target item based on manifest.name
+            const targetApp = targetMarketplaceApps.find((targetApp) => (0, lodash_1.get)(targetApp, 'manifest.name') === (0, lodash_1.get)(sourceApp, 'manifest.name'));
+            if (targetApp) {
+                // Map app_uid from source and target
+                this.marketplaceAppMapper.app_uid[sourceApp.manifest.uid] = targetApp.manifest.uid;
+                // Map installation_uid from source and target
+                this.marketplaceAppMapper.installation_uid[sourceApp.installation_uid] = targetApp.installation_uid;
+                // Map extension_uid by comparing meta.uid in source and target's ui_location.locations
+                sourceApp.ui_location.locations.forEach((sourceAppLocation) => {
+                    const targetAppLocation = targetApp.ui_location.locations.find((targetAppLocation) => targetAppLocation.type === sourceAppLocation.type);
+                    if (targetAppLocation) {
+                        sourceAppLocation.meta.forEach((sourceAppMeta) => {
+                            const targetAppMeta = targetAppLocation.meta.find((targetAppMeta) => targetAppMeta.uid === sourceAppMeta.uid);
+                            if (targetAppMeta && sourceAppMeta.extension_uid && targetAppMeta.extension_uid) {
+                                this.marketplaceAppMapper.extension_uid[sourceAppMeta.extension_uid] = targetAppMeta.extension_uid;
+                            }
+                        });
+                    }
+                });
+            }
+        });
+    }
+}
+exports.default = marketplaceAppImportSetup;

package/lib/import/modules/taxonomies.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="lodash" />
+import { ModuleClassParams } from '../../types';
+export default class TaxonomiesImportSetup {
+    private config;
+    private taxonomiesFilePath;
+    private stackAPIClient;
+    private dependencies;
+    private taxonomiesConfig;
+    private termsSuccessPath;
+    private taxSuccessPath;
+    private taxonomiesMapperDirPath;
+    private termsMapperDirPath;
+    taxonomiesMapper: Record<string, unknown>;
+    termsMapper: Record<string, unknown>;
+    constructor({ config, stackAPIClient }: ModuleClassParams);
+    /**
+     * Start the taxonomies import setup
+     * This method reads the taxonomies from the content folder and generates a mapper file
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+    /**
+     * Retrieves the taxonomies based on the provided taxonomy UID.
+     *
+     * @param taxonomy - The UID of the taxonomy to retrieve.
+     * @returns A promise that resolves to the retrieved taxonomies.
+     */
+    getTaxonomies(taxonomy: any): Promise<any>;
+    /**
+     * Sanitizes the attributes of a taxonomy object.
+     *
+     * @param taxonomy - The taxonomy object to sanitize.
+     * @returns The sanitized taxonomy object with invalid keys omitted.
+     */
+    sanitizeTaxonomyAttribs(taxonomy: Record<string, string>): import("lodash").Omit<Record<string, string>, string>;
+    /**
+     * Retrieves all terms of a taxonomy.
+     *
+     * @param taxonomy - The taxonomy object.
+     * @param skip - The number of terms to skip (default: 0).
+     * @param terms - An array to store the retrieved terms (default: []).
+     * @returns A promise that resolves to an array of terms.
+     */
+    getAllTermsOfTaxonomy(taxonomy: any, skip?: number, terms?: any[]): Promise<any>;
+    /**
+     * Sanitizes the attributes of the given terms.
+     *
+     * @param terms - An array of terms to sanitize.
+     * @returns The sanitized terms.
+     */
+    sanitizeTermsAttribs(terms: Record<string, unknown>[]): Record<string, unknown>[];
+    handleTaxonomyErrorMsg(err: any): void;
+}

package/lib/import/modules/taxonomies.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path_1 = require("path");
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const utils_1 = require("../../utils");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+class TaxonomiesImportSetup {
+    constructor({ config, stackAPIClient }) {
+        this.taxonomiesMapper = {};
+        this.termsMapper = {};
+        this.config = config;
+        this.stackAPIClient = stackAPIClient;
+        this.taxonomiesFilePath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.contentDir), 'taxonomies', 'taxonomies.json');
+        this.taxonomiesConfig = config.modules.taxonomies;
+        this.taxonomiesMapperDirPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'taxonomies');
+        this.taxSuccessPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.taxonomiesMapperDirPath), 'success.json');
+        this.termsMapperDirPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.taxonomiesMapperDirPath), 'terms');
+        this.termsSuccessPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.termsMapperDirPath), 'success.json');
+        this.taxonomiesMapper = {};
+        this.termsMapper = {};
+    }
+    /**
+     * Start the taxonomies import setup
+     * This method reads the taxonomies from the content folder and generates a mapper file
+     * @returns {Promise<void>}
+     */
+    async start() {
+        try {
+            const taxonomies = utils_1.fsUtil.readFile(this.taxonomiesFilePath);
+            if (!(0, isEmpty_1.default)(taxonomies)) {
+                // 2. Create mapper directory
+                utils_1.fsUtil.makeDirectory(this.taxonomiesMapperDirPath);
+                utils_1.fsUtil.makeDirectory(this.termsMapperDirPath);
+                for (const taxonomy of Object.values(taxonomies)) {
+                    let targetTaxonomy = await this.getTaxonomies(taxonomy);
+                    if (!targetTaxonomy) {
+                        (0, utils_1.log)(this.config, `Taxonomies with uid '${taxonomy.uid}' not found in the stack!`, 'info');
+                        continue;
+                    }
+                    targetTaxonomy = this.sanitizeTaxonomyAttribs(targetTaxonomy);
+                    this.taxonomiesMapper[taxonomy.uid] = targetTaxonomy;
+                    const terms = await this.getAllTermsOfTaxonomy(targetTaxonomy);
+                    const sanitizedTerms = this.sanitizeTermsAttribs(terms);
+                    this.termsMapper[taxonomy.uid] = sanitizedTerms;
+                }
+                if (this.taxonomiesMapper !== undefined && !(0, isEmpty_1.default)(this.taxonomiesMapper)) {
+                    utils_1.fsUtil.writeFile(this.taxSuccessPath, this.taxonomiesMapper);
+                }
+                if (this.termsMapper !== undefined && !(0, isEmpty_1.default)(this.termsMapper)) {
+                    utils_1.fsUtil.writeFile(this.termsSuccessPath, this.termsMapper);
+                }
+                (0, utils_1.log)(this.config, `Generated required setup files for taxonomies`, 'success');
+            }
+            else {
+                (0, utils_1.log)(this.config, 'No taxonomies found in the content folder!', 'info');
+            }
+        }
+        catch (error) {
+            (0, utils_1.log)(this.config, `Error generating taxonomies mapper: ${error.message}`, 'error');
+        }
+    }
+    /**
+     * Retrieves the taxonomies based on the provided taxonomy UID.
+     *
+     * @param taxonomy - The UID of the taxonomy to retrieve.
+     * @returns A promise that resolves to the retrieved taxonomies.
+     */
+    async getTaxonomies(taxonomy) {
+        return await this.stackAPIClient
+            .taxonomy(taxonomy.uid)
+            .fetch()
+            .then((data) => data)
+            .catch((err) => this.handleTaxonomyErrorMsg(err));
+    }
+    /**
+     * Sanitizes the attributes of a taxonomy object.
+     *
+     * @param taxonomy - The taxonomy object to sanitize.
+     * @returns The sanitized taxonomy object with invalid keys omitted.
+     */
+    sanitizeTaxonomyAttribs(taxonomy) {
+        return (0, omit_1.default)(taxonomy, this.taxonomiesConfig.invalidKeys);
+    }
+    /**
+     * Retrieves all terms of a taxonomy.
+     *
+     * @param taxonomy - The taxonomy object.
+     * @param skip - The number of terms to skip (default: 0).
+     * @param terms - An array to store the retrieved terms (default: []).
+     * @returns A promise that resolves to an array of terms.
+     */
+    async getAllTermsOfTaxonomy(taxonomy, skip = 0, terms = []) {
+        const queryParams = {
+            include_count: true,
+            limit: 100,
+            skip,
+        };
+        if (skip >= 0)
+            queryParams['skip'] = skip || 0;
+        queryParams['depth'] = 0;
+        await this.stackAPIClient
+            .taxonomy(taxonomy.uid)
+            .terms()
+            .query(queryParams)
+            .find()
+            .then((data) => {
+            terms = terms.concat(data.items);
+            if (data.count >= skip + queryParams.limit) {
+                return this.getAllTermsOfTaxonomy(taxonomy, skip + 100, terms);
+            }
+        })
+            .catch((err) => this.handleTaxonomyErrorMsg(err));
+        return terms;
+    }
+    /**
+     * Sanitizes the attributes of the given terms.
+     *
+     * @param terms - An array of terms to sanitize.
+     * @returns The sanitized terms.
+     */
+    sanitizeTermsAttribs(terms) {
+        for (let index = 0; index < (terms === null || terms === void 0 ? void 0 : terms.length); index++) {
+            terms[index] = (0, omit_1.default)(terms[index], this.taxonomiesConfig.invalidKeys);
+        }
+        return terms;
+    }
+    handleTaxonomyErrorMsg(err) {
+        var _a, _b;
+        if ((err === null || err === void 0 ? void 0 : err.errorMessage) || (err === null || err === void 0 ? void 0 : err.message)) {
+            const errorMsg = (err === null || err === void 0 ? void 0 : err.errorMessage) || ((_a = err === null || err === void 0 ? void 0 : err.errors) === null || _a === void 0 ? void 0 : _a.taxonomy) || ((_b = err === null || err === void 0 ? void 0 : err.errors) === null || _b === void 0 ? void 0 : _b.term) || (err === null || err === void 0 ? void 0 : err.message);
+            (0, utils_1.log)(this.config, errorMsg, 'error');
+        }
+        else {
+            (0, utils_1.log)(this.config, 'Error fetching taxonomy data!', 'error');
+            (0, utils_1.log)(this.config, err, 'error');
+        }
+    }
+}
+exports.default = TaxonomiesImportSetup;