@rockcarver/frodo-lib 0.11.0

package/src/ops/IdmOps.js

@@ -0,0 +1,227 @@
+import fs from 'fs';
+import fse from 'fs-extra';
+import replaceall from 'replaceall';
+import propertiesReader from 'properties-reader';
+import {
+  getAllConfigEntities,
+  getConfigEntity,
+  queryAllManagedObjectsByType,
+} from '../api/IdmConfigApi.js';
+import { printMessage, showSpinner, succeedSpinner } from './utils/Console.js';
+import { getTypedFilename } from './utils/ExportImportUtils.js';
+
+/**
+ * List all IDM configuration objects
+ */
+export async function listAllConfigEntities() {
+  let configEntities = [];
+  try {
+    configEntities = (await getAllConfigEntities()).data;
+  } catch (getAllConfigEntitiesError) {
+    printMessage(getAllConfigEntitiesError, 'error');
+    printMessage(
+      `Error getting config entities: ${getAllConfigEntitiesError}`,
+      'error'
+    );
+  }
+  if ('configurations' in configEntities) {
+    configEntities.configurations.forEach((configEntity) => {
+      printMessage(`${configEntity._id}`, 'data');
+    });
+  }
+}
+
+/**
+ * Export an IDM configuration object.
+ * @param {String} id the desired configuration object
+ * @param {String} file optional export file
+ */
+export async function exportConfigEntity(id, file) {
+  let fileName = file;
+  if (!fileName) {
+    fileName = getTypedFilename(`${id}`, 'idm');
+  }
+  const configEntity = (await getConfigEntity(id)).data;
+  fs.writeFile(fileName, JSON.stringify(configEntity, null, 2), (err) => {
+    if (err) {
+      return printMessage(`ERROR - can't save ${id} export to file`, 'error');
+    }
+    return '';
+  });
+}
+
+/**
+ * Export all IDM configuration objects into separate JSON files in a directory specified by <directory>
+ * @param {String} directory export directory
+ */
+export async function exportAllRawConfigEntities(directory) {
+  let configEntities = [];
+  try {
+    configEntities = (await getAllConfigEntities()).data;
+  } catch (getAllConfigEntitiesError) {
+    printMessage(getAllConfigEntitiesError, 'error');
+    printMessage(
+      `Error getting config entities: ${getAllConfigEntitiesError}`,
+      'error'
+    );
+  }
+  if ('configurations' in configEntities) {
+    if (!fs.existsSync(directory)) {
+      fs.mkdirSync(directory);
+    }
+    showSpinner('Exporting config objects...');
+    const entityPromises = [];
+    configEntities.configurations.forEach((x) => {
+      entityPromises.push(
+        getConfigEntity(x._id)
+          .then((response) => response.data)
+          .catch((getConfigEntityError) => {
+            if (
+              !(
+                getConfigEntityError.response.status === 403 &&
+                getConfigEntityError.response.data.message ===
+                  'This operation is not available in ForgeRock Identity Cloud.'
+              )
+            ) {
+              printMessage(getConfigEntityError, 'error');
+              printMessage(
+                `Error getting config entity: ${getConfigEntityError}`,
+                'error'
+              );
+            }
+          })
+      );
+    });
+    Promise.all(entityPromises).then((result) => {
+      // console.log(result);
+      result.forEach((item) => {
+        if (item != null) {
+          fse.outputFile(
+            `${directory}/${item._id}.json`,
+            JSON.stringify(item, null, 2),
+            // eslint-disable-next-line consistent-return
+            (err) => {
+              if (err) {
+                return printMessage(
+                  `ERROR - can't save config ${item._id} to file - ${err}`,
+                  'error'
+                );
+              }
+            }
+          );
+        }
+      });
+      succeedSpinner();
+    });
+  }
+}
+
+/**
+ * Export all IDM configuration objects
+ * @param {String} directory export directory
+ * @param {String} entitiesFile JSON file that specifies the config entities to export/import
+ * @param {String} envFile File that defines environment specific variables for replacement during configuration export/import
+ */
+export async function exportAllConfigEntities(
+  directory,
+  entitiesFile,
+  envFile
+) {
+  let entriesToExport = [];
+  // read list of entities to export
+  fs.readFile(entitiesFile, 'utf8', async (err, data) => {
+    if (err) throw err;
+    const entriesData = JSON.parse(data);
+    entriesToExport = entriesData.idm;
+    // console.log(`entriesToExport ${entriesToExport}`);
+
+    // read list of configs to parameterize for environment specific values
+    const envParams = propertiesReader(envFile);
+
+    let configEntities = [];
+    try {
+      configEntities = (await getAllConfigEntities()).data;
+    } catch (getAllConfigEntitiesError) {
+      printMessage(getAllConfigEntitiesError, 'error');
+      printMessage(
+        `Error getting config entities: ${getAllConfigEntitiesError}`,
+        'error'
+      );
+    }
+    if ('configurations' in configEntities) {
+      // create export directory if not exist
+      if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory);
+      }
+      showSpinner('Exporting config objects...');
+      const entityPromises = [];
+      configEntities.configurations.forEach((x) => {
+        if (entriesToExport.includes(x._id)) {
+          // console.log(`- ${x._id}`);
+          entityPromises.push(
+            getConfigEntity(x._id).then((response) => response.data)
+          );
+        }
+      });
+      Promise.all(entityPromises).then((result) => {
+        // console.log(result);
+        result.forEach((item) => {
+          if (item != null) {
+            let configEntityString = JSON.stringify(item, null, 2);
+            envParams.each((key, value) => {
+              configEntityString = replaceall(
+                value,
+                `\${${key}}`,
+                configEntityString
+              );
+            });
+            fse.outputFile(
+              `${directory}/${item._id}.json`,
+              JSON.stringify(item, null, 2),
+              // eslint-disable-next-line consistent-return
+              (error) => {
+                if (err) {
+                  return printMessage(
+                    `ERROR - can't save config ${item._id} to file - ${error}`,
+                    'error'
+                  );
+                }
+              }
+            );
+          }
+        });
+        succeedSpinner();
+      });
+    }
+  });
+}
+
+/**
+ * Count number of managed objects of a given type
+ * @param {String} type managed object type, e.g. alpha_user
+ */
+export async function countManagedObjects(type) {
+  let count = 0;
+  let result = {
+    result: [],
+    resultCount: 0,
+    pagedResultsCookie: null,
+    totalPagedResultsPolicy: 'NONE',
+    totalPagedResults: -1,
+    remainingPagedResults: -1,
+  };
+  try {
+    do {
+      // eslint-disable-next-line no-await-in-loop
+      result = (
+        await queryAllManagedObjectsByType(type, [], result.pagedResultsCookie)
+      ).data;
+      count += result.resultCount;
+      // printMessage(result);
+    } while (result.pagedResultsCookie);
+    printMessage(`${type}: ${count}`);
+  } catch (error) {
+    printMessage(error.response.data, 'error');
+    printMessage(`Error querying managed objects by type: ${error}`, 'error');
+  }
+}

package/src/ops/IdpOps.js

@@ -0,0 +1,342 @@
+import fs from 'fs';
+import {
+  getSocialIdentityProviders,
+  putProviderByTypeAndId,
+} from '../api/SocialIdentityProvidersApi.js';
+import { getScript } from '../api/ScriptApi.js';
+import { createOrUpdateScript } from './ScriptOps.js';
+import {
+  convertBase64TextToArray,
+  convertTextArrayToBase64,
+  getRealmString,
+  getTypedFilename,
+  saveJsonToFile,
+  validateImport,
+} from './utils/ExportImportUtils.js';
+import {
+  printMessage,
+  createProgressBar,
+  updateProgressBar,
+  stopProgressBar,
+} from './utils/Console.js';
+
+// use a function vs a template variable to avoid problems in loops
+function getFileDataTemplate() {
+  return {
+    meta: {},
+    script: {},
+    idp: {},
+  };
+}
+
+/**
+ * List providers
+ */
+export async function listProviders() {
+  getSocialIdentityProviders()
+    .then((response) => {
+      response.data.result.sort((a, b) => a._id.localeCompare(b._id));
+      response.data.result.forEach((socialIdentityProvider) => {
+        printMessage(`${socialIdentityProvider._id}`, 'data');
+      });
+    })
+    .catch((err) => {
+      printMessage(`listProviders ERROR: ${err.message}`, 'error');
+      printMessage(err, 'error');
+    });
+}
+
+/**
+ * Get social identity provider by id
+ * @param {String} id social identity provider id/name
+ * @returns {Promise} a promise that resolves a social identity provider object
+ */
+export async function getSocialIdentityProviderById(id) {
+  return getSocialIdentityProviders().then((response) => {
+    const foundProviders = response.data.result.filter(
+      (provider) => provider._id === id
+    );
+    switch (foundProviders.length) {
+      case 1:
+        return foundProviders[0];
+      case 0:
+        throw new Error(`Provider '${id}' not found`);
+      default:
+        throw new Error(`${foundProviders.length} providers '${id}' found`);
+    }
+  });
+}
+
+/**
+ * Export provider by id
+ * @param {String} id provider id/name
+ * @param {String} file optional export file name
+ */
+export async function exportProvider(id, file = null) {
+  let fileName = file;
+  if (!fileName) {
+    fileName = getTypedFilename(id, 'idp');
+  }
+  createProgressBar(1, `Exporting ${id}`);
+  try {
+    const idpData = await getSocialIdentityProviderById(id);
+    updateProgressBar(`Writing file ${fileName}`);
+    const fileData = getFileDataTemplate();
+    fileData.idp[idpData._id] = idpData;
+    if (idpData.transform) {
+      const scriptData = (await getScript(idpData.transform)).data;
+      scriptData.script = convertBase64TextToArray(scriptData.script);
+      fileData.script[idpData.transform] = scriptData;
+    }
+    saveJsonToFile(fileData, fileName);
+    stopProgressBar(`Exported ${id.brightCyan} to ${fileName.brightCyan}.`);
+  } catch (err) {
+    stopProgressBar(`${err}`);
+    printMessage(`${err}`, 'error');
+  }
+}
+
+/**
+ * Export all providers
+ * @param {String} file optional export file name
+ */
+export async function exportProvidersToFile(file) {
+  let fileName = file;
+  if (!fileName) {
+    fileName = getTypedFilename(`all${getRealmString()}Providers`, 'idp');
+  }
+  const fileData = getFileDataTemplate();
+  const allIdpsData = (await getSocialIdentityProviders()).data.result;
+  createProgressBar(allIdpsData.length, 'Exporting providers');
+  for (const idpData of allIdpsData) {
+    updateProgressBar(`Exporting provider ${idpData._id}`);
+    fileData.idp[idpData._id] = idpData;
+    if (idpData.transform) {
+      // eslint-disable-next-line no-await-in-loop
+      const scriptData = (await getScript(idpData.transform)).data;
+      scriptData.script = convertBase64TextToArray(scriptData.script);
+      fileData.script[idpData.transform] = scriptData;
+    }
+  }
+  saveJsonToFile(fileData, fileName);
+  stopProgressBar(`${allIdpsData.length} providers exported to ${fileName}.`);
+}
+
+/**
+ * Export all providers to individual files
+ */
+export async function exportProvidersToFiles() {
+  const allIdpsData = await (await getSocialIdentityProviders()).data.result;
+  // printMessage(allIdpsData, 'data');
+  createProgressBar(allIdpsData.length, 'Exporting providers');
+  for (const idpData of allIdpsData) {
+    updateProgressBar(`Writing provider ${idpData._id}`);
+    const fileName = getTypedFilename(idpData._id, 'idp');
+    const fileData = getFileDataTemplate();
+    fileData.idp[idpData._id] = idpData;
+    if (idpData.transform) {
+      // eslint-disable-next-line no-await-in-loop
+      const scriptData = (await getScript(idpData.transform)).data;
+      scriptData.script = convertBase64TextToArray(scriptData.script);
+      fileData.script[idpData.transform] = scriptData;
+    }
+    saveJsonToFile(fileData, fileName);
+  }
+  stopProgressBar(`${allIdpsData.length} providers exported.`);
+}
+
+/**
+ * Import provider by id/name
+ * @param {String} id provider id/name
+ * @param {String} file import file name
+ */
+export async function importProviderById(id, file) {
+  fs.readFile(file, 'utf8', async (err, data) => {
+    if (err) throw err;
+    const fileData = JSON.parse(data);
+    if (validateImport(fileData.meta)) {
+      createProgressBar(1, 'Importing provider...');
+      let found = false;
+      for (const idpId in fileData.idp) {
+        if ({}.hasOwnProperty.call(fileData.idp, idpId)) {
+          if (idpId === id) {
+            found = true;
+            updateProgressBar(`Importing ${fileData.idp[idpId]._id}`);
+            const scriptId = fileData.idp[idpId].transform;
+            const scriptData = fileData.script[scriptId];
+            if (scriptId && scriptData) {
+              scriptData.script = convertTextArrayToBase64(scriptData.script);
+              // eslint-disable-next-line no-await-in-loop
+              await createOrUpdateScript(
+                fileData.idp[idpId].transform,
+                fileData.script[fileData.idp[idpId].transform]
+              );
+            }
+            putProviderByTypeAndId(
+              fileData.idp[idpId]._type._id,
+              idpId,
+              fileData.idp[idpId]
+            )
+              .then(() => {
+                stopProgressBar(`Successfully imported provider ${id}.`);
+              })
+              .catch((importProviderErr) => {
+                stopProgressBar(
+                  `Error importing provider ${fileData.idp[idpId]._id}`
+                );
+                printMessage(`\nError importing provider ${id}`, 'error');
+                printMessage(importProviderErr.response.data, 'error');
+              });
+            break;
+          }
+        }
+      }
+      if (!found) {
+        stopProgressBar(
+          `Provider ${id.brightCyan} not found in ${file.brightCyan}!`
+        );
+      }
+    } else {
+      printMessage('Import validation failed...', 'error');
+    }
+  });
+}
+
+/**
+ * Import first provider from file
+ * @param {String} file import file name
+ */
+export async function importFirstProvider(file) {
+  fs.readFile(file, 'utf8', async (err, data) => {
+    if (err) throw err;
+    const fileData = JSON.parse(data);
+    if (validateImport(fileData.meta)) {
+      createProgressBar(1, 'Importing provider...');
+      for (const idpId in fileData.idp) {
+        if ({}.hasOwnProperty.call(fileData.idp, idpId)) {
+          updateProgressBar(`Importing ${fileData.idp[idpId]._id}`);
+          const scriptId = fileData.idp[idpId].transform;
+          const scriptData = fileData.script[scriptId];
+          if (scriptId && scriptData) {
+            scriptData.script = convertTextArrayToBase64(scriptData.script);
+            // eslint-disable-next-line no-await-in-loop
+            await createOrUpdateScript(
+              fileData.idp[idpId].transform,
+              fileData.script[fileData.idp[idpId].transform]
+            );
+          }
+          putProviderByTypeAndId(
+            fileData.idp[idpId]._type._id,
+            idpId,
+            fileData.idp[idpId]
+          ).then((result) => {
+            if (result == null) {
+              stopProgressBar(
+                `Error importing provider ${fileData.idp[idpId]._id}`
+              );
+              printMessage(
+                `Error importing provider ${fileData.idp[idpId]._id}`,
+                'error'
+              );
+            } else {
+              stopProgressBar(
+                `Successfully imported provider ${fileData.idp[idpId]._id}.`
+              );
+            }
+          });
+          break;
+        }
+      }
+    } else {
+      printMessage('Import validation failed...', 'error');
+    }
+  });
+}
+
+/**
+ * Import all providers from file
+ * @param {String} file import file name
+ */
+export async function importProvidersFromFile(file) {
+  fs.readFile(file, 'utf8', async (err, data) => {
+    if (err) throw err;
+    const fileData = JSON.parse(data);
+    if (validateImport(fileData.meta)) {
+      createProgressBar(
+        Object.keys(fileData.idp).length,
+        'Importing providers...'
+      );
+      for (const idpId in fileData.idp) {
+        if ({}.hasOwnProperty.call(fileData.idp, idpId)) {
+          const scriptId = fileData.idp[idpId].transform;
+          const scriptData = fileData.script[scriptId];
+          if (scriptId && scriptData) {
+            scriptData.script = convertTextArrayToBase64(scriptData.script);
+            // eslint-disable-next-line no-await-in-loop
+            await createOrUpdateScript(
+              fileData.idp[idpId].transform,
+              fileData.script[fileData.idp[idpId].transform]
+            );
+          }
+          // eslint-disable-next-line no-await-in-loop
+          const result = await putProviderByTypeAndId(
+            fileData.idp[idpId]._type._id,
+            idpId,
+            fileData.idp[idpId]
+          );
+          if (!result) {
+            updateProgressBar(
+              `Successfully imported ${fileData.idp[idpId].name}`
+            );
+          }
+        }
+      }
+      stopProgressBar(`Providers imported.`);
+    } else {
+      printMessage('Import validation failed...', 'error');
+    }
+  });
+}
+
+/**
+ * Import providers from *.idp.json files in current working directory
+ */
+export async function importProvidersFromFiles() {
+  const names = fs.readdirSync('.');
+  const jsonFiles = names.filter((name) =>
+    name.toLowerCase().endsWith('.idp.json')
+  );
+
+  createProgressBar(jsonFiles.length, 'Importing providers...');
+  let total = 0;
+  for (const file of jsonFiles) {
+    const data = fs.readFileSync(file, 'utf8');
+    const fileData = JSON.parse(data);
+    if (validateImport(fileData.meta)) {
+      const count = Object.keys(fileData.idp).length;
+      total += count;
+      for (const idpId in fileData.idp) {
+        if ({}.hasOwnProperty.call(fileData.idp, idpId)) {
+          // eslint-disable-next-line no-await-in-loop
+          const result = await putProviderByTypeAndId(
+            fileData.idp[idpId]._type._id,
+            idpId,
+            fileData.idp[idpId]
+          );
+          if (result == null) {
+            printMessage(
+              `Error importing ${count} providers from ${file}`,
+              'error'
+            );
+          }
+        }
+      }
+      updateProgressBar(`Imported ${count} provider(s) from ${file}`);
+    } else {
+      printMessage(`Validation of ${file} failed!`, 'error');
+    }
+  }
+  stopProgressBar(
+    `Finished importing ${total} provider(s) from ${jsonFiles.length} file(s).`
+  );
+}