@contentstack/cli-cm-export-to-csv 1.5.0 → 1.6.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contentstack/cli-cm-export-to-csv",
   "description": "Export entities to csv",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "author": "Abhinav Gupta @abhinav-from-contentstack",
   "bugs": "https://github.com/contentstack/cli/issues",
   "dependencies": {
@@ -15,12 +15,15 @@
   },
   "devDependencies": {
     "@oclif/test": "^2.2.10",
-    "chai": "^4.2.0",
+    "@types/chai": "^4.3.6",
+    "@types/mocha": "^10.0.1",
+    "chai": "^4.3.8",
     "debug": "^4.3.1",
+    "dotenv": "^16.3.1",
     "eslint": "^7.32.0",
     "eslint-config-oclif": "^4.0.0",
     "globby": "^10.0.2",
-    "mocha": "^10.0.0",
+    "mocha": "^10.2.0",
     "nyc": "^15.1.0",
     "oclif": "^3.8.1"
   },
@@ -44,7 +47,8 @@
     "postpack": "rm -f oclif.manifest.json",
     "prepack": "oclif manifest && oclif readme",
     "test": "nyc mocha --forbid-only \"test/**/*.test.js\"",
-    "test:unit": "nyc mocha --timeout 10000 --forbid-only \"test/unit/**/*.test.js\"",
+    "test:unit": "mocha --timeout 10000 --forbid-only \"test/unit/**/*.test.js\" \"test/util/common-utils.test.js\"",
+    "test:unit:report": "nyc --extension .js mocha --forbid-only \"test/unit/**/*.test.js\" \"test/util/common-utils.test.js\"",
     "version": "oclif readme && git add README.md",
     "clean": "rm -rf ./node_modules tsconfig.build.tsbuildinfo"
   },
@@ -61,4 +65,4 @@
     }
   },
   "repository": "https://github.com/contentstack/cli"
-}
+}

package/src/commands/cm/export-to-csv.js

@@ -15,8 +15,8 @@ class ExportToCsvCommand extends Command {
     action: flags.string({
       required: false,
       multiple: false,
-      options: ['entries', 'users', 'teams'],
-      description: `Option to export data (entries, users, teams)`,
+      options: ['entries', 'users', 'teams', 'taxonomies'],
+      description: `Option to export data (entries, users, teams, taxonomies)`,
     }),
     alias: flags.string({
       char: 'a',
@@ -61,7 +61,14 @@ class ExportToCsvCommand extends Command {
     }),
     "team-uid": flags.string({
       description: 'Uid of the team whose user data and stack roles are required'
-    })
+    }),
+    'taxonomy-uid': flags.string({
+      description: 'Provide the taxonomy UID of the related terms you want to export',
+    }),
+    delimiter: flags.string({
+      description: '[optional] Provide a delimiter to separate individual data fields within the CSV file.',
+      default: ',',
+    }),
   };
 
   async run() {
@@ -78,7 +85,9 @@ class ExportToCsvCommand extends Command {
           'content-type': contentTypesFlag,
           alias: managementTokenAlias,
           branch: branchUid,
-          "team-uid": teamUid
+          "team-uid": teamUid,
+          'taxonomy-uid': taxonomyUID,
+          delimiter
         },
       } = await this.parse(ExportToCsvCommand);
 
@@ -106,61 +115,17 @@ class ExportToCsvCommand extends Command {
             let stackAPIClient;
             let language;
             let contentTypes = [];
-            let stackBranches;
-            const listOfTokens = configHandler.get('tokens');
-
-            if (managementTokenAlias && listOfTokens[managementTokenAlias]) {
-              managementAPIClient = await managementSDKClient({
-                host: this.cmaHost,
-                management_token: listOfTokens[managementTokenAlias].token,
-              });
-              stack = {
-                name: stackName || managementTokenAlias,
-                apiKey: listOfTokens[managementTokenAlias].apiKey,
-                token: listOfTokens[managementTokenAlias].token,
-              };
-            } else if (managementTokenAlias) {
-              this.error('Provided management token alias not found in your config.!');
+
+            if (managementTokenAlias) {
+              const { stackDetails, apiClient } = await this.getAliasDetails(managementTokenAlias, stackName);
+              managementAPIClient = apiClient;
+              stack = stackDetails;
             } else {
-              let organization;
-              if (org) {
-                organization = { uid: org };
-              } else {
-                organization = await util.chooseOrganization(managementAPIClient); // prompt for organization
-              }
-              if (!stackAPIKey) {
-                stack = await util.chooseStack(managementAPIClient, organization.uid); // prompt for stack
-              } else {
-                stack = await util.chooseStack(managementAPIClient, organization.uid, stackAPIKey);
-              }
+              stack = await this.getStackDetails(managementAPIClient, stackAPIKey, org);
             }
 
             stackAPIClient = this.getStackClient(managementAPIClient, stack);
-
-            if (branchUid) {
-              try {
-                const branchExists = await doesBranchExist(stackAPIClient, branchUid);
-                if (branchExists?.errorCode) {
-                  throw new Error(branchExists.errorMessage);
-                }
-                stack.branch_uid = branchUid;
-                stackAPIClient = this.getStackClient(managementAPIClient, stack);
-              } catch (error) {
-                if (error.message || error.errorMessage) {
-                  cliux.error(util.formatError(error));
-                  this.exit();
-                }
-              }
-            } else {
-              stackBranches = await this.getStackBranches(stackAPIClient);
-              if (stackBranches === undefined) {
-                stackAPIClient = this.getStackClient(managementAPIClient, stack);
-              } else {
-                const { branch } = await util.chooseBranch(stackBranches);
-                stack.branch_uid = branch;
-                stackAPIClient = this.getStackClient(managementAPIClient, stack);
-              }
-            }
+            await this.checkAndUpdateBranchDetail(branchUid, stack, stackAPIClient, managementAPIClient);
 
             const contentTypeCount = await util.getContentTypeCount(stackAPIClient);
 
@@ -219,7 +184,7 @@ class ExportToCsvCommand extends Command {
                 flatEntries = flatEntries.concat(flatEntriesResult);
               }
               let fileName = `${stackName ? stackName : stack.name}_${contentType}_${language.code}_entries_export.csv`;
-              util.write(this, flatEntries, fileName, 'entries'); // write to file
+              util.write(this, flatEntries, fileName, 'entries', delimiter); // write to file
             }
           } catch (error) {
             cliux.error(util.formatError(error));
@@ -246,7 +211,7 @@ class ExportToCsvCommand extends Command {
               (orgName ? orgName : organization.name).replace(config.organizationNameRegex, ''),
             )}_users_export.csv`;
 
-            util.write(this, listOfUsers, fileName, 'organization details');
+            util.write(this, listOfUsers, fileName, 'organization details', delimiter);
           } catch (error) {
             if (error.message || error.errorMessage) {
               cliux.error(util.formatError(error));
@@ -264,14 +229,30 @@ class ExportToCsvCommand extends Command {
               organization = await util.chooseOrganization(managementAPIClient, action); // prompt for organization
             }
           
-            await util.exportTeams(managementAPIClient,organization,teamUid);
+            await util.exportTeams(managementAPIClient,organization,teamUid, delimiter);
           } catch (error) {
             if (error.message || error.errorMessage) {
               cliux.error(util.formatError(error));
             }
           }
+          break;
+        }
+        case config.exportTaxonomies:
+        case 'taxonomies': {
+          let stack;
+          let stackAPIClient;
+          if (managementTokenAlias) {
+            const { stackDetails, apiClient } = await this.getAliasDetails(managementTokenAlias, stackName);
+            managementAPIClient = apiClient;
+            stack = stackDetails;
+          } else {
+            stack = await this.getStackDetails(managementAPIClient, stackAPIKey, org);
+          }
+
+          stackAPIClient = this.getStackClient(managementAPIClient, stack);
+          await this.createTaxonomyAndTermCsvFile(stackAPIClient, stackName, stack, taxonomyUID, delimiter);
+          break;
         }
-        break;
       }
     } catch (error) {
       if (error.message || error.errorMessage) {
@@ -287,8 +268,8 @@ class ExportToCsvCommand extends Command {
   getStackClient(managementAPIClient, stack) {
     const stackInit = {
       api_key: stack.apiKey,
-      branch_uid: stack.branch_uid,
     };
+    if (stack?.branch_uid) stackInit['branch_uid'] = stack.branch_uid;
     if (stack.token) {
       return managementAPIClient.stack({
         ...stackInit,
@@ -306,9 +287,159 @@ class ExportToCsvCommand extends Command {
       .then(({ items }) => (items !== undefined ? items : []))
       .catch((_err) => {});
   }
+
+  /**
+   * check whether branch enabled org or not and update branch details
+   * @param {string} branchUid
+   * @param {object} stack
+   * @param {*} stackAPIClient
+   * @param {*} managementAPIClient
+   */
+  async checkAndUpdateBranchDetail(branchUid, stack, stackAPIClient, managementAPIClient) {
+    if (branchUid) {
+      try {
+        const branchExists = await doesBranchExist(stackAPIClient, branchUid);
+        if (branchExists?.errorCode) {
+          throw new Error(branchExists.errorMessage);
+        }
+        stack.branch_uid = branchUid;
+        stackAPIClient = this.getStackClient(managementAPIClient, stack);
+      } catch (error) {
+        if (error?.message || error?.errorMessage) {
+          cliux.error(util.formatError(error));
+          this.exit();
+        }
+      }
+    } else {
+      const stackBranches = await this.getStackBranches(stackAPIClient);
+      if (stackBranches === undefined) {
+        stackAPIClient = this.getStackClient(managementAPIClient, stack);
+      } else {
+        const { branch } = await util.chooseBranch(stackBranches);
+        stack.branch_uid = branch;
+        stackAPIClient = this.getStackClient(managementAPIClient, stack);
+      }
+    }
+  }
+
+  /**
+   * fetch stack details from alias token
+   * @param {string} managementTokenAlias
+   * @param {string} stackName
+   * @returns
+   */
+  async getAliasDetails(managementTokenAlias, stackName) {
+    let apiClient, stackDetails;
+    const listOfTokens = configHandler.get('tokens');
+    if (managementTokenAlias && listOfTokens[managementTokenAlias]) {
+      apiClient = await managementSDKClient({
+        host: this.cmaHost,
+        management_token: listOfTokens[managementTokenAlias].token,
+      });
+      stackDetails = {
+        name: stackName || managementTokenAlias,
+        apiKey: listOfTokens[managementTokenAlias].apiKey,
+        token: listOfTokens[managementTokenAlias].token,
+      };
+    } else if (managementTokenAlias) {
+      this.error('Provided management token alias not found in your config.!');
+    }
+    return {
+      apiClient,
+      stackDetails,
+    };
+  }
+
+  /**
+   * fetch stack details on basis of the selected org and stack
+   * @param {*} managementAPIClient
+   * @param {string} stackAPIKey
+   * @param {string} org
+   * @returns
+   */
+  async getStackDetails(managementAPIClient, stackAPIKey, org) {
+    let organization, stackDetails;
+
+    if (!isAuthenticated()) {
+      this.error(config.CLI_EXPORT_CSV_ENTRIES_ERROR, {
+        exit: 2,
+        suggestions: ['https://www.contentstack.com/docs/developers/cli/authentication/'],
+      });
+    }
+
+    if (org) {
+      organization = { uid: org };
+    } else {
+      organization = await util.chooseOrganization(managementAPIClient); // prompt for organization
+    }
+    if (!stackAPIKey) {
+      stackDetails = await util.chooseStack(managementAPIClient, organization.uid); // prompt for stack
+    } else {
+      stackDetails = await util.chooseStack(managementAPIClient, organization.uid, stackAPIKey);
+    }
+    return stackDetails;
+  }
+
+  /**
+   * Create a taxonomies csv file for stack and a terms csv file for associated taxonomies
+   * @param {string} stackName
+   * @param {object} stack
+   * @param {string} taxUID
+   */
+  async createTaxonomyAndTermCsvFile(stackAPIClient, stackName, stack, taxUID, delimiter) {
+    //TODO: Temp variable to export taxonomies in importable format will replaced with flag once decided
+    const importableCSV = true;
+    const payload = {
+      stackAPIClient,
+      type: '',
+      limit: config.limit || 100,
+    };
+    //check whether the taxonomy is valid or not
+    let taxonomies = [];
+    if (taxUID) {
+      payload['taxonomyUID'] = taxUID;
+      const taxonomy = await util.getTaxonomy(payload);
+      taxonomies.push(taxonomy);
+    } else {
+      taxonomies = await util.getAllTaxonomies(payload);
+    }
+
+    if (!importableCSV) {
+      const formattedTaxonomiesData = util.formatTaxonomiesData(taxonomies);
+      if (formattedTaxonomiesData?.length) {
+        const fileName = `${stackName ? stackName : stack.name}_taxonomies.csv`;
+        util.write(this, formattedTaxonomiesData, fileName, 'taxonomies', delimiter);
+      } else {
+        cliux.print('info: No taxonomies found! Please provide a valid stack.', { color: 'blue' });
+      }
+
+      for (let index = 0; index < taxonomies?.length; index++) {
+        const taxonomy = taxonomies[index];
+        const taxonomyUID = taxonomy?.uid;
+        if (taxonomyUID) {
+          payload['taxonomyUID'] = taxonomyUID;
+          const terms = await util.getAllTermsOfTaxonomy(payload);
+          const formattedTermsData = util.formatTermsOfTaxonomyData(terms, taxonomyUID);
+          const taxonomyName = taxonomy?.name ?? '';
+          const termFileName = `${stackName ?? stack.name}_${taxonomyName}_${taxonomyUID}_terms.csv`;
+          if (formattedTermsData?.length) {
+            util.write(this, formattedTermsData, termFileName, 'terms', delimiter);
+          } else {
+            cliux.print(`info: No terms found for the taxonomy UID - '${taxonomyUID}'!`, { color: 'blue' });
+          }
+        }
+      }
+    } else {
+      const fileName = `${stackName ?? stack.name}_taxonomies.csv`;
+      const { taxonomiesData, headers } = await util.createImportableCSV(payload, taxonomies);
+      if (taxonomiesData?.length) {
+        util.write(this, taxonomiesData, fileName, 'taxonomies',delimiter, headers);
+      }
+    }
+  }
 }
 
-ExportToCsvCommand.description = `Export entries or organization users to csv using this command`;
+ExportToCsvCommand.description = `Export entries, taxonomies, terms or organization users to csv using this command`;
 
 ExportToCsvCommand.examples = [
   'csdx cm:export-to-csv',
@@ -339,6 +470,15 @@ ExportToCsvCommand.examples = [
   '',
   'Exporting Organizations Teams to CSV with org-uid and team uid',
   'csdx cm:export-to-csv --action <teams> --org <org-uid> --team-uid <team-uid> --org-name <org-name>',
+  '',
+  'Exporting taxonomies and related terms to a .CSV file with the provided taxonomy UID',
+  'csdx cm:export-to-csv --action <taxonomies> --alias <management-token-alias> --taxonomy-uid <taxonomy-uid>',
+  '',
+  'Exporting taxonomies and respective terms to a .CSV file',
+  'csdx cm:export-to-csv --action <taxonomies> --alias <management-token-alias>',
+  '',
+  'Exporting taxonomies and respective terms to a .CSV file with a delimiter',
+  'csdx cm:export-to-csv --action <taxonomies> --alias <management-token-alias> --delimiter <delimiter>',
 ];
 
 module.exports = ExportToCsvCommand;

package/src/util/config.js

@@ -1,11 +1,13 @@
 module.exports = {
+  limit:100,
   cancelString: 'Cancel and Exit',
   exportEntries: 'Export entries to a .CSV file',
   exportUsers: "Export organization user's data to a .CSV file",
   exportTeams: "Export organization team's data to a .csv file",
+  exportTaxonomies: 'Export taxonomies to a .CSV file',
   adminError: "Unable to export data. Make sure you're an admin or owner of this organization",
   organizationNameRegex: /\'/,
   CLI_EXPORT_CSV_LOGIN_FAILED: "You need to login to execute this command. See: auth:login --help",
   CLI_EXPORT_CSV_ENTRIES_ERROR: "You need to either login or provide a management token to execute this command",
-  CLI_EXPORT_CSV_API_FAILED: 'Something went wrong. Please try again!'
+  CLI_EXPORT_CSV_API_FAILED: 'Something went wrong! Please try again'
 };

package/src/util/index.js

@@ -4,12 +4,21 @@ const mkdirp = require('mkdirp');
 const find = require('lodash/find');
 const cloneDeep = require('lodash/cloneDeep');
 const omit = require('lodash/omit');
+const flat = require('lodash/flatten');
 const fastcsv = require('fast-csv');
 const inquirer = require('inquirer');
 const debug = require('debug')('export-to-csv');
 const checkboxPlus = require('inquirer-checkbox-plus-prompt');
 const config = require('./config.js');
-const { cliux, configHandler, HttpClient } = require('@contentstack/cli-utilities');
+const {
+  cliux,
+  configHandler,
+  HttpClient,
+  messageHandler,
+  managementSDKClient,
+  ContentstackClient,
+} = require('@contentstack/cli-utilities');
+
 const directory = './data';
 const delimeter = os.platform() === 'win32' ? '\\' : '/';
 
@@ -155,9 +164,7 @@ function chooseStack(managementAPIClient, orgUid, stackApiKey) {
 
 async function chooseBranch(branchList) {
   try {
-    const branches = await branchList;
-
-    const branchesArray = branches.map((branch) => branch.uid);
+    const branchesArray = branchList.map((branch) => branch.uid);
 
     let _chooseBranch = [
       {
@@ -377,20 +384,20 @@ function exitProgram() {
   process.exit();
 }
 
-function sanitizeEntries(flatEntry) {
+function sanitizeData(flatData) {
   // sanitize against CSV Injections
   const CSVRegex = /^[\\+\\=@\\-]/;
-  for (key in flatEntry) {
-    if (typeof flatEntry[key] === 'string' && flatEntry[key].match(CSVRegex)) {
-      flatEntry[key] = flatEntry[key].replace(/\"/g, "\"\"");
-      flatEntry[key] = `"'${flatEntry[key]}"`;
-    } else if (typeof flatEntry[key] === 'object') {
+  for (key in flatData) {
+    if (typeof flatData[key] === 'string' && flatData[key].match(CSVRegex)) {
+      flatData[key] = flatData[key].replace(/\"/g, "\"\"");
+      flatData[key] = `"'${flatData[key]}"`;
+    } else if (typeof flatData[key] === 'object') {
       // convert any objects or arrays to string
       // to store this data correctly in csv
-      flatEntry[key] = JSON.stringify(flatEntry[key]);
+      flatData[key] = JSON.stringify(flatData[key]);
     }
   }
-  return flatEntry;
+  return flatData;
 }
 
 function cleanEntries(entries, language, environments, contentTypeUid) {
@@ -400,7 +407,7 @@ function cleanEntries(entries, language, environments, contentTypeUid) {
   return filteredEntries.map((entry) => {
     let workflow = '';
     const envArr = [];
-    if (entry.publish_details.length) {
+    if (entry?.publish_details?.length) {
       entry.publish_details.forEach((env) => {
         envArr.push(JSON.stringify([environments[env['environment']], env['locale'], env['time']]));
       });
@@ -415,7 +422,7 @@ function cleanEntries(entries, language, environments, contentTypeUid) {
       }
     }
     entry = flatten(entry);
-    entry = sanitizeEntries(entry);
+    entry = sanitizeData(entry);
     entry['publish_details'] = envArr;
     entry['_workflow'] = workflow;
     entry['ACL'] = JSON.stringify({}); // setting ACL to empty obj
@@ -443,7 +450,7 @@ function getDateTime() {
   return dateTime.join('_');
 }
 
-function write(command, entries, fileName, message) {
+function write(command, entries, fileName, message, delimiter, headers) {
   // eslint-disable-next-line no-undef
   if (process.cwd().split(delimeter).pop() !== 'data' && !fs.existsSync(directory)) {
     mkdirp.sync(directory);
@@ -455,7 +462,8 @@ function write(command, entries, fileName, message) {
   }
   // eslint-disable-next-line no-undef
   cliux.print(`Writing ${message} to file: ${process.cwd()}${delimeter}${fileName}`);
-  fastcsv.writeToPath(fileName, entries, { headers: true });
+  if (headers?.length) fastcsv.writeToPath(fileName, entries, { headers, delimiter });
+  else fastcsv.writeToPath(fileName, entries, { headers: true, delimiter });
 }
 
 function startupQuestions() {
@@ -465,7 +473,7 @@ function startupQuestions() {
         type: 'list',
         name: 'action',
         message: 'Choose Action',
-        choices: [config.exportEntries, config.exportUsers, config.exportTeams, 'Exit'],
+        choices: [config.exportEntries, config.exportUsers, config.exportTeams, config.exportTaxonomies, 'Exit'],
       },
     ];
     inquirer
@@ -780,7 +788,7 @@ async function cleanTeamsData(data, managementAPIClient, org) {
   }
 }
 
-async function exportTeams(managementAPIClient, organization, teamUid) {
+async function exportTeams(managementAPIClient, organization, teamUid, delimiter) {
   cliux.print(
     `info: Exporting the ${
       teamUid && organization?.name
@@ -799,13 +807,13 @@ async function exportTeams(managementAPIClient, organization, teamUid) {
       delete team['stackRoleMapping'];
     });
     const fileName = `${kebabize(organization.name.replace(config.organizationNameRegex, ''))}_teams_export.csv`;
-    write(this, modifiedTeam, fileName, ' organization Team details');
+    write(this, modifiedTeam, fileName, ' organization Team details', delimiter);
     // exporting teams user data or a single team user data
     cliux.print(
       `info: Exporting the teams user data for ${teamUid ? `team ` + teamUid : `organisation ` + organization?.name}`,
       { color: 'blue' },
     );
-    await getTeamsDetail(allTeamsData, organization, teamUid);
+    await getTeamsDetail(allTeamsData, organization, teamUid, delimiter);
     cliux.print(
       `info: Exporting the stack role details for  ${
         teamUid ? `team ` + teamUid : `organisation ` + organization?.name
@@ -813,18 +821,18 @@ async function exportTeams(managementAPIClient, organization, teamUid) {
       { color: 'blue' },
     );
     // Exporting the stack Role data for all the teams or exporting stack role data for a single team
-    await exportRoleMappings(managementAPIClient, allTeamsData, teamUid);
+    await exportRoleMappings(managementAPIClient, allTeamsData, teamUid, delimiter);
   }
 }
 
-async function getTeamsDetail(allTeamsData, organization, teamUid) {
+async function getTeamsDetail(allTeamsData, organization, teamUid, delimiter) {
   if (!teamUid) {
     const userData = await getTeamsUserDetails(allTeamsData);
     const fileName = `${kebabize(
       organization.name.replace(config.organizationNameRegex, ''),
     )}_team_User_Details_export.csv`;
 
-    write(this, userData, fileName, 'Team User details');
+    write(this, userData, fileName, 'Team User details', delimiter);
   } else {
     const team = allTeamsData.filter((team) => team.uid === teamUid)[0];
 
@@ -839,11 +847,11 @@ async function getTeamsDetail(allTeamsData, organization, teamUid) {
       organization.name.replace(config.organizationNameRegex, ''),
     )}_team_${teamUid}_User_Details_export.csv`;
 
-    write(this, team.users, fileName, 'Team User details');
+    write(this, team.users, fileName, 'Team User details', delimiter);
   }
 }
 
-async function exportRoleMappings(managementAPIClient, allTeamsData, teamUid) {
+async function exportRoleMappings(managementAPIClient, allTeamsData, teamUid, delimiter) {
   let stackRoleWithTeamData = [];
   let flag = false;
   const stackNotAdmin = [];
@@ -900,7 +908,7 @@ async function exportRoleMappings(managementAPIClient, allTeamsData, teamUid) {
     teamUid ? `_${teamUid}` : ''
   }.csv`;
 
-  write(this, stackRoleWithTeamData, fileName, 'Team Stack Role details');
+  write(this, stackRoleWithTeamData, fileName, 'Team Stack Role details', delimiter);
 }
 
 async function mapRoleWithTeams(managementAPIClient, stackRoleMapping, teamName, teamUid) {
@@ -949,6 +957,214 @@ async function getTeamsUserDetails(teamsObject) {
   return allTeamUsers;
 }
 
+/**
+ * fetch all taxonomies in the provided stack
+ * @param {object} payload
+ * @param {number} skip
+ * @param {array} taxonomies
+ * @returns
+ */
+async function getAllTaxonomies(payload, skip = 0, taxonomies = []) {
+  payload['type'] = 'taxonomies';
+  const { items, count } = await taxonomySDKHandler(payload, skip);
+  if (items) {
+    skip += payload.limit;
+    taxonomies.push(...items);
+    if (skip >= count) {
+      return taxonomies;
+    } else {
+      return getAllTaxonomies(payload, skip, taxonomies);
+    }
+  }
+  return taxonomies;
+}
+
+/**
+ * fetch taxonomy related terms
+ * @param {object} payload
+ * @param {number} skip
+ * @param {number} limit
+ * @param {array} terms
+ * @returns
+ */
+async function getAllTermsOfTaxonomy(payload, skip = 0, terms = []) {
+  payload['type'] = 'terms';
+  const { items, count } = await taxonomySDKHandler(payload, skip);
+  if (items) {
+    skip += payload.limit;
+    terms.push(...items);
+    if (skip >= count) {
+      return terms;
+    } else {
+      return getAllTermsOfTaxonomy(payload, skip, terms);
+    }
+  }
+  return terms;
+}
+
+/**
+ * Verify the existence of a taxonomy. Obtain its details if it exists and return
+ * @param {object} payload
+ * @param {string} taxonomyUID
+ * @returns
+ */
+async function getTaxonomy(payload) {
+  payload['type'] = 'taxonomy';
+  const resp = await taxonomySDKHandler(payload);
+  return resp;
+}
+
+/**
+ * taxonomy & term sdk handler
+ * @async
+ * @method
+ * @param payload
+ * @param skip
+ * @param limit
+ * @returns  {*} Promise<any>
+ */
+async function taxonomySDKHandler(payload, skip) {
+  const { stackAPIClient, taxonomyUID, type } = payload;
+
+  const queryParams = { include_count: true, limit: payload.limit };
+  if (skip >= 0) queryParams['skip'] = skip || 0;
+
+  switch (type) {
+    case 'taxonomies':
+      return await stackAPIClient
+        .taxonomy()
+        .query(queryParams)
+        .find()
+        .then((data) => data)
+        .catch((err) => handleErrorMsg(err));
+    case 'taxonomy':
+      return await stackAPIClient
+        .taxonomy(taxonomyUID)
+        .fetch()
+        .then((data) => data)
+        .catch((err) => handleErrorMsg(err));
+    case 'terms':
+      queryParams['depth'] = 0;
+      return await stackAPIClient
+        .taxonomy(taxonomyUID)
+        .terms()
+        .query(queryParams)
+        .find()
+        .then((data) => data)
+        .catch((err) => handleErrorMsg(err));
+    default:
+      handleErrorMsg({ errorMessage: 'Invalid module!' });
+  }
+}
+
+/**
+ * Change taxonomies data in required CSV headers format
+ * @param {array} taxonomies
+ * @returns
+ */
+function formatTaxonomiesData(taxonomies) {
+  if (taxonomies?.length) {
+    const formattedTaxonomies = taxonomies.map((taxonomy) => {
+      return sanitizeData({
+        'Taxonomy UID': taxonomy.uid,
+        Name: taxonomy.name,
+        Description: taxonomy.description,
+      });
+    });
+    return formattedTaxonomies;
+  }
+}
+
+/**
+ * Modify the linked taxonomy data's terms in required CSV headers format
+ * @param {array} terms
+ * @param {string} taxonomyUID
+ * @returns
+ */
+function formatTermsOfTaxonomyData(terms, taxonomyUID) {
+  if (terms?.length) {
+    const formattedTerms = terms.map((term) => {
+      return sanitizeData({
+        'Taxonomy UID': taxonomyUID,
+        UID: term.uid,
+        Name: term.name,
+        'Parent UID': term.parent_uid,
+        Depth: term.depth,
+      });
+    });
+    return formattedTerms;
+  }
+}
+
+function handleErrorMsg(err) {
+  if (err?.errorMessage) {
+    cliux.print(`Error: ${err.errorMessage}`, { color: 'red' });
+  } else if (err?.message) {
+    const errorMsg = err?.errors?.taxonomy || err?.errors?.term || err?.message;
+    cliux.print(`Error: ${errorMsg}`, { color: 'red' });
+  } else {
+    console.log(err);
+    cliux.print(`Error: ${messageHandler.parse('CLI_EXPORT_CSV_API_FAILED')}`, { color: 'red' });
+  }
+  process.exit(1);
+}
+
+/**
+ * create an importable CSV file, to utilize with the migration script.
+ * @param {*} payload api request payload
+ * @param {*} taxonomies taxonomies data
+ * @returns
+ */
+async function createImportableCSV(payload, taxonomies) {
+  let taxonomiesData = [];
+  let headers = ['Taxonomy Name','Taxonomy UID','Taxonomy Description'];
+  for (let index = 0; index < taxonomies?.length; index++) {
+    const taxonomy = taxonomies[index];
+    const taxonomyUID = taxonomy?.uid;
+    if (taxonomyUID) {
+      const sanitizedTaxonomy = sanitizeData({
+        'Taxonomy Name': taxonomy?.name,
+        'Taxonomy UID': taxonomyUID,
+        'Taxonomy Description': taxonomy?.description,
+      });
+      taxonomiesData.push(sanitizedTaxonomy);
+      payload['taxonomyUID'] = taxonomyUID;
+      const terms = await getAllTermsOfTaxonomy(payload);
+      //fetch all parent terms
+      const parentTerms = terms.filter((term) => term?.parent_uid === null);
+      const termsData = getParentAndChildTerms(parentTerms, terms, headers);
+      taxonomiesData.push(...termsData)
+    }
+  }
+
+  return {taxonomiesData, headers};
+}
+
+/**
+ * Get the parent and child terms, then arrange them hierarchically in a CSV file.
+ * @param {*} parentTerms list of parent terms
+ * @param {*} terms respective terms of taxonomies
+ * @param {*} headers list of csv headers include taxonomy and terms column
+ * @param {*} termsData parent and child terms
+ */
+function getParentAndChildTerms(parentTerms, terms, headers, termsData=[]) {
+  for (let i = 0; i < parentTerms?.length; i++) {
+    const parentTerm = parentTerms[i];
+    const levelUID = `Term Level${parentTerm.depth} UID`;
+    const levelName = `Term Level${parentTerm.depth} Name`;
+    if (headers.indexOf(levelName) === -1) headers.push(levelName);
+    if (headers.indexOf(levelUID) === -1) headers.push(levelUID);
+    const sanitizedTermData = sanitizeData({ [levelName]: parentTerm.name, [levelUID]: parentTerm.uid });
+    termsData.push(sanitizedTermData);
+    //fetch all sibling terms
+    const newParents = terms.filter((term) => term.parent_uid === parentTerm.uid);
+    if (newParents?.length) {
+      getParentAndChildTerms(newParents, terms, headers, termsData);
+    }
+  }
+  return termsData;
+}
+
 module.exports = {
   chooseOrganization: chooseOrganization,
   chooseStack: chooseStack,
@@ -977,4 +1193,11 @@ module.exports = {
   formatError: formatError,
   exportOrgTeams: exportOrgTeams,
   exportTeams: exportTeams,
+  getAllTaxonomies,
+  getAllTermsOfTaxonomy,
+  formatTaxonomiesData,
+  formatTermsOfTaxonomyData,
+  getTaxonomy,
+  getStacks,
+  createImportableCSV,
 };