@contentstack/cli-cm-export-to-csv 1.6.1 → 1.7.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Contentstack
+Copyright (c) 2024 Contentstack
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@contentstack/cli-cm-export-to-csv",
   "description": "Export entities to csv",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "author": "Abhinav Gupta @abhinav-from-contentstack",
   "bugs": "https://github.com/contentstack/cli/issues",
   "dependencies": {
     "@contentstack/cli-command": "~1.2.16",
-    "@contentstack/cli-utilities": "~1.5.7",
+    "@contentstack/cli-utilities": "~1.5.12",
     "chalk": "^4.1.0",
     "fast-csv": "^4.3.6",
     "inquirer": "8.2.4",
@@ -14,7 +14,7 @@
     "mkdirp": "^3.0.1"
   },
   "devDependencies": {
-    "@oclif/test": "^2.2.10",
+    "@oclif/test": "^2.5.6",
     "@types/chai": "^4.3.6",
     "@types/mocha": "^10.0.1",
     "chai": "^4.3.8",

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

@@ -334,8 +334,8 @@ class ExportToCsvCommand extends Command {
     const listOfTokens = configHandler.get('tokens');
     if (managementTokenAlias && listOfTokens[managementTokenAlias]) {
       const checkManagementTokenValidity = await isManagementTokenValid((listOfTokens[managementTokenAlias].apiKey) ,listOfTokens[managementTokenAlias].token);
-      if(!checkManagementTokenValidity?.valid) {
-        throw checkManagementTokenValidity.hasOwnProperty('valid')?(`error: Management token or stack API key is invalid. ${checkManagementTokenValidity?.message||""}`):checkManagementTokenValidity?.message||"";
+      if(checkManagementTokenValidity.hasOwnProperty('message')) {
+        throw checkManagementTokenValidity.valid==='failedToCheck'?checkManagementTokenValidity.message:(`error: Management token or stack API key is invalid. ${checkManagementTokenValidity.message}`);
       }
       apiClient = await managementSDKClient({
         host: this.cmaHost,
@@ -449,31 +449,31 @@ ExportToCsvCommand.description = `Export entries, taxonomies, terms or organizat
 ExportToCsvCommand.examples = [
   'csdx cm:export-to-csv',
   '',
-  'Exporting entries to csv',
+  'Exporting entries to CSV',
   'csdx cm:export-to-csv --action <entries> --locale <locale> --alias <management-token-alias> --content-type <content-type>',
   '',
-  'Exporting entries to csv with stack name provided and branch name provided',
+  'Exporting entries to CSV with stack name provided and branch name provided',
   'csdx cm:export-to-csv --action <entries> --locale <locale> --alias <management-token-alias> --content-type <content-type> --stack-name <stack-name> --branch <branch-name>',
   '',
-  'Exporting organization users to csv',
+  'Exporting organization users to CSV',
   'csdx cm:export-to-csv --action <users> --org <org-uid>',
   '',
-  'Exporting organization users to csv with organization name provided',
+  'Exporting organization users to CSV with organization name provided',
   'csdx cm:export-to-csv --action <users> --org <org-uid> --org-name <org-name>',
   '',
-  'Exporting Organizations Teams to CSV',
+  'Exporting organization teams to CSV',
   'csdx cm:export-to-csv --action <teams>',
   '',
-  'Exporting Organizations Teams to CSV with org-uid',
+  'Exporting organization teams to CSV with org UID',
   'csdx cm:export-to-csv --action <teams> --org <org-uid>',
   '',
-  'Exporting Organizations Teams to CSV with team uid',
+  'Exporting organization teams to CSV with team UID',
   'csdx cm:export-to-csv --action <teams> --team-uid <team-uid>',
   '',
-  'Exporting Organizations Teams to CSV with org-uid and team uid',
+  'Exporting organization teams to CSV with org UID and team UID',
   'csdx cm:export-to-csv --action <teams> --org <org-uid> --team-uid <team-uid>',
   '',
-  'Exporting Organizations Teams to CSV with org-uid and team uid',
+  'Exporting organization 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',

package/src/util/config.js

@@ -2,8 +2,8 @@ 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",
+  exportUsers: "Export organization users' data to a .CSV file",
+  exportTeams: "Export organization teams' 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: /\'/,

package/src/util/index.js

@@ -62,7 +62,6 @@ async function getOrganizations(managementAPIClient) {
   try {
     return await getOrganizationList(managementAPIClient, { skip: 0, page: 1, limit: 100 }, []);
   } catch (error) {
-    console.log(error);
     throw error;
   }
 }
@@ -461,7 +460,7 @@ function write(command, entries, fileName, message, delimiter, headers) {
     process.chdir(directory);
   }
   // eslint-disable-next-line no-undef
-  cliux.print(`Writing ${message} to file: ${process.cwd()}${delimeter}${fileName}`);
+  cliux.print(`Writing ${message} to file: "${process.cwd()}${delimeter}${fileName}"`);
   if (headers?.length) fastcsv.writeToPath(fileName, entries, { headers, delimiter });
   else fastcsv.writeToPath(fileName, entries, { headers: true, delimiter });
 }
@@ -693,54 +692,59 @@ function wait(time) {
 }
 
 function handleErrorMsg(err) {
-  cliux.print(`Error: ${(err?.errorMessage || err?.message) ? err?.errorMessage || err?.message : messageHandler.parse('CLI_EXPORT_CSV_API_FAILED')}`, { color: 'red' })
+  cliux.print(`Error: ${(err?.errorMessage || err?.message) ?? messageHandler.parse('CLI_EXPORT_CSV_API_FAILED')}`, {
+    color: 'red',
+  });
   process.exit(1);
 }
 
-async function apiRequestHandler(org, queryParam = {}) {
-  const headers = {
-    authtoken: configHandler.get('authtoken'),
-    organization_uid: org.uid,
-    'Content-Type': 'application/json',
-    api_version: 1.1,
-  };
-
-  return await new HttpClient()
-    .headers(headers)
-    .queryParams(queryParam)
-    .get(`${configHandler.get('region')?.cma}/organizations/${org?.uid}/teams`)
-    .then((res) => {
-      const { status, data } = res;
-      if (status === 200) {
-        return data;
-      } else {
-        cliux.print(`${data?.error_message || data?.message || data?.errorMessage}`, { color: 'red' });
-        process.exit(1);
-      }
-    })
-    .catch((error) => {
-      handleErrorMsg(error);
-    });
+/**
+ * This function does the sdk calls to get all the teams in org
+ * @param {object} managementAPIClient
+ * @param {object} org
+ * @param {object} queryParam
+ * @returns
+ */
+async function getAllTeams(managementAPIClient, org, queryParam = {}) {
+  try {
+    return await managementAPIClient.organization(org.uid).teams().fetchAll(queryParam);
+  } catch (error) {
+    handleErrorMsg(error);
+  }
 }
 
+/**
+ * This function is used to handle the pagination and call the sdk
+ * @param {object} managementAPIClient
+ * @param {object} org
+ */
 async function exportOrgTeams(managementAPIClient, org) {
-  let teamsObjectArray = [];
+  let allTeamsInOrg = [];
   let skip = 0;
   let limit = config?.limit || 100;
   do {
-    const data = await apiRequestHandler(org, { skip: skip, limit: limit, includeUserDetails: true });
+    const data = await getAllTeams(managementAPIClient, org, {
+      skip: skip,
+      limit: limit,
+      includeUserDetails: true,
+    });
     skip += limit;
-    teamsObjectArray.push(...data?.teams);
+    allTeamsInOrg.push(...data.items);
     if (skip >= data?.count) break;
   } while (1);
-  teamsObjectArray = await cleanTeamsData(teamsObjectArray, managementAPIClient, org);
-  return teamsObjectArray;
+  allTeamsInOrg = await cleanTeamsData(allTeamsInOrg, managementAPIClient, org);
+  return allTeamsInOrg;
 }
 
+/**
+ * This function will get all the org level roles
+ * @param {object} managementAPIClient
+ * @param {object} org
+ */
 async function getOrgRolesForTeams(managementAPIClient, org) {
   let roleMap = {}; // for org level there are two roles only admin and member
 
-  // SDK call to get the role uids
+  // SDK call to get the role UIDs
   await managementAPIClient
     .organization(org.uid)
     .roles()
@@ -757,6 +761,12 @@ async function getOrgRolesForTeams(managementAPIClient, org) {
   return roleMap;
 }
 
+/**
+ * Removes the unnecessary fields from the objects in the data and assign org level roles to the team based on role uid
+ * @param {array} data
+ * @param {object} managementAPIClient
+ * @param {object} org
+ */
 async function cleanTeamsData(data, managementAPIClient, org) {
   const roleMap = await getOrgRolesForTeams(managementAPIClient, org);
   const fieldToBeDeleted = [
@@ -769,18 +779,24 @@ async function cleanTeamsData(data, managementAPIClient, org) {
     'createdByUserName',
     'updatedByUserName',
     'organizationUid',
+    'urlPath',
+    'update',
+    'delete',
+    'fetch',
+    'stackRoleMappings',
+    'teamUsers',
   ];
   if (data?.length) {
     return data.map((team) => {
       team = omit(team, fieldToBeDeleted);
-    
-      team.organizationRole = (team.organizationRole === roleMap["member"]) ? "member" : "admin";
-    
-      if (!team.hasOwnProperty("description")) {
-        team.description = "";
+
+      team.organizationRole = team.organizationRole === roleMap['member'] ? 'member' : 'admin';
+
+      if (!team.hasOwnProperty('description')) {
+        team.description = '';
       }
       team.Total_Members = team?.users?.length || 0;
-    
+
       return team;
     });
   } else {
@@ -788,6 +804,13 @@ async function cleanTeamsData(data, managementAPIClient, org) {
   }
 }
 
+/**
+ * This function is used to call all the other teams function to export the required files
+ * @param {object} managementAPIClient
+ * @param {object} organization
+ * @param {string} teamUid
+ * @param {character} delimiter
+ */
 async function exportTeams(managementAPIClient, organization, teamUid, delimiter) {
   cliux.print(
     `info: Exporting the ${
@@ -799,7 +822,9 @@ async function exportTeams(managementAPIClient, organization, teamUid, delimiter
   );
   const allTeamsData = await exportOrgTeams(managementAPIClient, organization);
   if (!allTeamsData?.length) {
-    cliux.print(`info: The organization ${organization?.name} does not have any teams associated with it. Please verify and provide the correct organization name.`);
+    cliux.print(
+      `info: The organization ${organization?.name} does not have any teams associated with it. Please verify and provide the correct organization name.`,
+    );
   } else {
     const modifiedTeam = cloneDeep(allTeamsData);
     modifiedTeam.forEach((team) => {
@@ -825,6 +850,13 @@ async function exportTeams(managementAPIClient, organization, teamUid, delimiter
   }
 }
 
+/**
+ * This function is used to get individual team user details and write to file
+ * @param {array} allTeamsData
+ * @param {object} organization
+ * @param {string} teamUid  optional
+ * @param {character} delimiter
+ */
 async function getTeamsDetail(allTeamsData, organization, teamUid, delimiter) {
   if (!teamUid) {
     const userData = await getTeamsUserDetails(allTeamsData);
@@ -835,14 +867,12 @@ async function getTeamsDetail(allTeamsData, organization, teamUid, delimiter) {
     write(this, userData, fileName, 'Team User details', delimiter);
   } else {
     const team = allTeamsData.filter((team) => team.uid === teamUid)[0];
-
     team.users.forEach((user) => {
       user['team-name'] = team.name;
       user['team-uid'] = team.uid;
       delete user['active'];
       delete user['orgInvitationStatus'];
     });
-
     const fileName = `${kebabize(
       organization.name.replace(config.organizationNameRegex, ''),
     )}_team_${teamUid}_User_Details_export.csv`;
@@ -851,16 +881,25 @@ async function getTeamsDetail(allTeamsData, organization, teamUid, delimiter) {
   }
 }
 
+/**
+ * This will export the role mappings of the team, for which stack the team has which role
+ * @param {object} managementAPIClient
+ * @param {array} allTeamsData Data for all the teams in the stack
+ * @param {string} teamUid for a particular team who's data we want
+ * @param {character} delimiter
+ */
 async function exportRoleMappings(managementAPIClient, allTeamsData, teamUid, delimiter) {
   let stackRoleWithTeamData = [];
   let flag = false;
   const stackNotAdmin = [];
   if (teamUid) {
-    const team = find(allTeamsData,function(teamObject) { return teamObject?.uid===teamUid });
+    const team = find(allTeamsData, function (teamObject) {
+      return teamObject?.uid === teamUid;
+    });
     for (const stack of team?.stackRoleMapping) {
       const roleData = await mapRoleWithTeams(managementAPIClient, stack, team?.name, team?.uid);
       stackRoleWithTeamData.push(...roleData);
-      if(roleData[0]['Stack Name']==='') {
+      if (roleData[0]['Stack Name'] === '') {
         flag = true;
         stackNotAdmin.push(stack.stackApiKey);
       }
@@ -870,18 +909,21 @@ async function exportRoleMappings(managementAPIClient, allTeamsData, teamUid, de
       for (const stack of team?.stackRoleMapping ?? []) {
         const roleData = await mapRoleWithTeams(managementAPIClient, stack, team?.name, team?.uid);
         stackRoleWithTeamData.push(...roleData);
-        if(roleData[0]['Stack Name']==='') {
+        if (roleData[0]['Stack Name'] === '') {
           flag = true;
           stackNotAdmin.push(stack.stackApiKey);
         }
       }
     }
   }
-  if(stackNotAdmin?.length) {
-    cliux.print(`warning: Admin access denied to the following stacks using the provided API keys. Please get in touch with the stack owner to request access.`,{color:"yellow"});
-    cliux.print(`${stackNotAdmin.join(' , ')}`,{color:"yellow"});
+  if (stackNotAdmin?.length) {
+    cliux.print(
+      `warning: Admin access denied to the following stacks using the provided API keys. Please get in touch with the stack owner to request access.`,
+      { color: 'yellow' },
+    );
+    cliux.print(`${stackNotAdmin.join(' , ')}`, { color: 'yellow' });
   }
-  if(flag) {
+  if (flag) {
     let export_stack_role = [
       {
         type: 'list',
@@ -889,19 +931,17 @@ async function exportRoleMappings(managementAPIClient, allTeamsData, teamUid, de
         message: `Access denied: Please confirm if you still want to continue exporting the data without the { Stack Name, Stack Uid, Role Name } fields.`,
         choices: ['yes', 'no'],
         loop: false,
-      }]
-      const exportStackRole = await inquirer
-      .prompt(export_stack_role)
-      .then(( chosenOrg ) => {
-        return chosenOrg
-      })
-      .catch((error) => {
-        cliux.print(error, {color:'red'});
-        process.exit(1);
-      });
-      if(exportStackRole.chooseExport === 'no') {
+      },
+    ];
+    try {
+      const exportStackRole = await inquirer.prompt(export_stack_role);
+      if (exportStackRole.chooseExport === 'no') {
         process.exit(1);
-      } 
+      }
+    } catch (error) {
+      cliux.print(error, { color: 'red' });
+      process.exit(1);
+    }
   }
 
   const fileName = `${kebabize('Stack_Role_Mapping'.replace(config.organizationNameRegex, ''))}${
@@ -911,13 +951,20 @@ async function exportRoleMappings(managementAPIClient, allTeamsData, teamUid, de
   write(this, stackRoleWithTeamData, fileName, 'Team Stack Role details', delimiter);
 }
 
+/**
+ * Mapping the team stacks with the stack role and returning and array of object
+ * @param {object} managementAPIClient
+ * @param {array} stackRoleMapping
+ * @param {string} teamName
+ * @param {string} teamUid
+ */
 async function mapRoleWithTeams(managementAPIClient, stackRoleMapping, teamName, teamUid) {
   const roles = await getRoleData(managementAPIClient, stackRoleMapping.stackApiKey);
   const stackRole = {};
   roles?.items?.forEach((role) => {
     if (!stackRole.hasOwnProperty(role?.uid)) {
       stackRole[role?.uid] = role?.name;
-      stackRole[role?.stack?.api_key] = {name: role?.stack?.name, uid: role?.stack?.uid }
+      stackRole[role?.stack?.api_key] = { name: role?.stack?.name, uid: role?.stack?.uid };
     }
   });
   const stackRoleMapOfTeam = stackRoleMapping?.roles.map((role) => {
@@ -933,17 +980,26 @@ async function mapRoleWithTeams(managementAPIClient, stackRoleMapping, teamName,
   return stackRoleMapOfTeam;
 }
 
+/**
+ * Making sdk call to get all the roles in the given stack
+ * @param {object} managementAPIClient
+ * @param {string} stackApiKey
+ */
 async function getRoleData(managementAPIClient, stackApiKey) {
   try {
     return await managementAPIClient.stack({ api_key: stackApiKey }).role().fetchAll();
   } catch (error) {
-    return {}
+    return {};
   }
 }
 
-async function getTeamsUserDetails(teamsObject) {
+/**
+ * Here in the users array we are adding the team-name and team-uid to individual users and returning an array of object of user details only
+ * @param {array} teams
+ */
+async function getTeamsUserDetails(teams) {
   const allTeamUsers = [];
-  teamsObject.forEach((team) => {
+  teams.forEach((team) => {
     if (team?.users?.length) {
       team.users.forEach((user) => {
         user['team-name'] = team.name;
@@ -1024,7 +1080,7 @@ async function getTaxonomy(payload) {
  * @returns  {*} Promise<any>
  */
 async function taxonomySDKHandler(payload, skip) {
-  const { stackAPIClient, taxonomyUID, type } = payload;
+  const { stackAPIClient, taxonomyUID, type, format } = payload;
 
   const queryParams = { include_count: true, limit: payload.limit };
   if (skip >= 0) queryParams['skip'] = skip || 0;
@@ -1036,13 +1092,13 @@ async function taxonomySDKHandler(payload, skip) {
         .query(queryParams)
         .find()
         .then((data) => data)
-        .catch((err) => handleErrorMsg(err));
+        .catch((err) => handleTaxonomyErrorMsg(err));
     case 'taxonomy':
       return await stackAPIClient
         .taxonomy(taxonomyUID)
         .fetch()
         .then((data) => data)
-        .catch((err) => handleErrorMsg(err));
+        .catch((err) => handleTaxonomyErrorMsg(err));
     case 'terms':
       queryParams['depth'] = 0;
       return await stackAPIClient
@@ -1051,9 +1107,15 @@ async function taxonomySDKHandler(payload, skip) {
         .query(queryParams)
         .find()
         .then((data) => data)
-        .catch((err) => handleErrorMsg(err));
+        .catch((err) => handleTaxonomyErrorMsg(err));
+    case 'export-taxonomies':
+      return await stackAPIClient
+        .taxonomy(taxonomyUID)
+        .export({ format })
+        .then((data) => data)
+        .catch((err) => handleTaxonomyErrorMsg(err));
     default:
-      handleErrorMsg({ errorMessage: 'Invalid module!' });
+      handleTaxonomyErrorMsg({ errorMessage: 'Invalid module!' });
   }
 }
 
@@ -1096,11 +1158,9 @@ function formatTermsOfTaxonomyData(terms, taxonomyUID) {
   }
 }
 
-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;
+function handleTaxonomyErrorMsg(err) {
+  if (err?.errorMessage || err?.message) {
+    const errorMsg = err?.errorMessage || err?.errors?.taxonomy || err?.errors?.term || err?.message;
     cliux.print(`Error: ${errorMsg}`, { color: 'red' });
   } else {
     console.log(err);
@@ -1110,60 +1170,53 @@ function handleErrorMsg(err) {
 }
 
 /**
- * create an importable CSV file, to utilize with the migration script.
+ * Generate a CSV file that can be imported for use 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)
+    let taxonomiesData = [];
+    let headers = [];
+    payload['type'] = 'export-taxonomies';
+    payload['format'] = 'csv';
+    for (const taxonomy of taxonomies) {
+      if (taxonomy?.uid) {
+        payload['taxonomyUID'] = taxonomy?.uid;
+        const data = await taxonomySDKHandler(payload);
+        const taxonomies = await csvParse(data, headers);
+        taxonomiesData.push(...taxonomies);
+      }
     }
-  }
 
-  return {taxonomiesData, headers};
+    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
+ * Parse the CSV data and segregate the headers from the actual data.
+ * @param {*} data taxonomy csv data with headers
+ * @param {*} headers list of csv headers
+ * @returns taxonomy data without headers
  */
-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;
-}
+const csvParse = (data, headers) => {
+  return new Promise((resolve, reject) => {
+    const taxonomies = [];
+    const stream = fastcsv.parseStream(fastcsv.parse());
+    stream.write(data);
+    stream.end();
+    stream
+      .on('data', (data) => {
+        taxonomies.push(data);
+      })
+      .on('error', (err) => reject(err))
+      .on('end', () => {
+        taxonomies[0]?.forEach((header) => {
+          if (!headers.includes(header)) headers.push(header);
+        });
+        resolve(taxonomies.splice(1));
+      });
+  });
+};
 
 module.exports = {
   chooseOrganization: chooseOrganization,