@rockcarver/frodo-lib 1.0.0 → 2.0.0-1

package/esm/ops/CirclesOfTrustOps.mjs

@@ -1,283 +1,332 @@
-import fs from 'fs';
-import _ from 'lodash';
-import { createTable, printMessage, createProgressIndicator, updateProgressIndicator, stopProgressIndicator } from './utils/Console';
-import { getCirclesOfTrust, getCircleOfTrust, createCircleOfTrust } from '../api/CirclesOfTrustApi';
-import { getRealmString, getTypedFilename, saveJsonToFile, validateImport } from './utils/ExportImportUtils';
+import { debugMessage } from './utils/Console';
+import { getCirclesOfTrust as _getCirclesOfTrust, getCircleOfTrust, createCircleOfTrust, updateCircleOfTrust } from '../api/CirclesOfTrustApi';
+import { getMetadata } from './utils/ExportImportUtils';
+export default class CirclesOfTrustOps {
+  constructor(state) {
+    this.state = state;
+  }
 
-// use a function vs a template variable to avoid problems in loops
-function getFileDataTemplate() {
-  return {
-    meta: {},
-    script: {},
-    saml: {
-      hosted: {},
-      remote: {},
-      metadata: {},
-      cot: {}
-    }
-  };
-}
+  /**
+   * Get SAML circle of trust
+   * @param {String} cotId circle of trust id/name
+   */
+  async getCircleOfTrust(cotId) {
+    return getCircleOfTrust({
+      cotId,
+      state: this.state
+    });
+  }
 
-/**
- * List entity providers
- * @param {String} long Long list format with details
- */
-export async function listCirclesOfTrust(long = false) {
-  let cotList = [];
-  try {
-    cotList = (await getCirclesOfTrust()).result;
-  } catch (error) {
-    printMessage(`getCirclesOfTrust ERROR: ${error}`, 'error');
-    printMessage(error, 'data');
+  /**
+   * Get SAML circles of trust
+   */
+  async getCirclesOfTrust() {
+    return getCirclesOfTrust({
+      state: this.state
+    });
   }
-  cotList.sort((a, b) => a._id.localeCompare(b._id));
-  if (!long) {
-    cotList.forEach(cot => {
-      printMessage(`${cot._id}`, 'data');
+
+  /**
+   * Export SAML circle of trust
+   * @param {String} cotId circle of trust id/name
+   */
+  async exportCircleOfTrust(cotId) {
+    return exportCircleOfTrust({
+      cotId,
+      state: this.state
     });
-  } else {
-    const table = createTable(['Name'['brightCyan'], 'Description'['brightCyan'], 'Status'['brightCyan'], 'Trusted Providers'['brightCyan']]);
-    cotList.forEach(cot => {
-      table.push([cot._id, cot.description, cot.status, cot.trustedProviders.map(provider => provider.split('|')[0]).join('\n')]);
+  }
+
+  /**
+   * Export all SAML circles of trust
+   */
+  async exportCirclesOfTrust() {
+    return exportCirclesOfTrust({
+      state: this.state
+    });
+  }
+
+  /**
+   * Import a SAML circle of trust by id/name from file
+   * @param {String} cotId Circle of trust id/name
+   * @param {CirclesOfTrustExportInterface} importData Import data
+   */
+  async importCircleOfTrust(cotId, importData) {
+    return importCircleOfTrust({
+      cotId,
+      importData,
+      state: this.state
+    });
+  }
+
+  /**
+   * Import first SAML circle of trust
+   * @param {CirclesOfTrustExportInterface} importData Import data
+   */
+  async importFirstCircleOfTrust(importData) {
+    return importFirstCircleOfTrust({
+      importData,
+      state: this.state
+    });
+  }
+
+  /**
+   * Import all SAML circles of trust
+   * @param {CirclesOfTrustExportInterface} importData Import file name
+   */
+  async importCirclesOfTrust(importData) {
+    return importCirclesOfTrust({
+      importData,
+      state: this.state
     });
-    printMessage(table.toString());
   }
 }
 
 /**
- * Include dependencies in the export file
- * @param {Object} cotData Object representing a SAML circle of trust
- * @param {Object} fileData File data object to add dependencies to
+ * Create an empty agent export template
+ * @returns {CirclesOfTrustExportInterface} an empty agent export template
  */
-async function exportDependencies(cotData, fileData) {
-  // TODO: Export dependencies
-  return [cotData, fileData];
+function createCirclesOfTrustExportTemplate({
+  state
+}) {
+  return {
+    meta: getMetadata({
+      state
+    }),
+    script: {},
+    saml: {
+      hosted: {},
+      remote: {},
+      metadata: {},
+      cot: {}
+    }
+  };
 }
+export { getCircleOfTrust };
 
 /**
- * Export a single circle of trust to file
- * @param {String} cotId circle of trust id/name
- * @param {String} file Optional filename
+ * Get circles of trust
  */
-export async function exportCircleOfTrust(cotId, file = null) {
-  let fileName = file;
-  if (!fileName) {
-    fileName = getTypedFilename(cotId, 'cot.saml');
-  }
-  createProgressIndicator(1, `Exporting circle of trust ${cotId}`);
-  try {
-    const cotData = _.cloneDeep(getCircleOfTrust(cotId));
-    delete cotData['_rev'];
-    updateProgressIndicator(`Exporting ${cotId}`);
-    const fileData = getFileDataTemplate();
-    fileData.saml.cot[cotId] = cotData;
-    await exportDependencies(cotData, fileData);
-    saveJsonToFile(fileData, fileName);
-    stopProgressIndicator(`Exported ${cotId.brightCyan} to ${fileName.brightCyan}.`);
-  } catch (err) {
-    stopProgressIndicator(`${err}`);
-    printMessage(err, 'error');
-  }
+export async function getCirclesOfTrust({
+  state
+}) {
+  const {
+    result
+  } = await _getCirclesOfTrust({
+    state
+  });
+  return result;
 }
 
 /**
- * Export all circles of trust to one file
- * @param {String} file Optional filename
+ * Export circle of trust
+ * @param {string} cotId circle of trust id/name
+ * @returns {Promise<CirclesOfTrustExportInterface>} a promise that resolves to an CirclesOfTrustExportInterface object
  */
-export async function exportCirclesOfTrustToFile(file = null) {
-  let fileName = file;
-  if (!fileName) {
-    fileName = getTypedFilename(`all${getRealmString()}CirclesOfTrust`, 'cot.saml');
-  }
-  const fileData = getFileDataTemplate();
-  let allCotData = [];
+export async function exportCircleOfTrust({
+  cotId,
+  state
+}) {
+  debugMessage(`CirclesOfTrustOps.exportCircleOfTrust: start`);
+  const exportData = createCirclesOfTrustExportTemplate({
+    state
+  });
+  const errors = [];
   try {
-    allCotData = _.cloneDeep((await getCirclesOfTrust()).result);
-    createProgressIndicator(allCotData.length, 'Exporting circles of trust');
-    for (const cotData of allCotData) {
-      delete cotData._rev;
-      updateProgressIndicator(`Exporting circle of trust ${cotData._id}`);
-      // eslint-disable-next-line no-await-in-loop
-      await exportDependencies(cotData, fileData);
-      fileData.saml.cot[cotData._id] = cotData;
-    }
-    saveJsonToFile(fileData, fileName);
-    stopProgressIndicator(`${allCotData.length} circle(s) of trust exported to ${fileName}.`);
+    const cotData = await getCircleOfTrust({
+      cotId,
+      state
+    });
+    exportData.saml.cot[cotData._id] = cotData;
   } catch (error) {
-    printMessage(`getCirclesOfTrust ERROR: ${error}`, 'error');
-    printMessage(error, 'data');
+    errors.push(error);
   }
+  if (errors.length) {
+    const errorMessages = errors.map(error => {
+      var _error$response;
+      if (((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.status) === 404) {
+        return `Circle of trust ${cotId} does not exist in realm ${state.getRealm()}`;
+      } else {
+        var _error$response2, _error$response2$data;
+        return ((_error$response2 = error.response) === null || _error$response2 === void 0 ? void 0 : (_error$response2$data = _error$response2.data) === null || _error$response2$data === void 0 ? void 0 : _error$response2$data.message) || error.message;
+      }
+    }).join('\n');
+    throw new Error(`Export error:\n${errorMessages}`);
+  }
+  debugMessage(`CirclesOfTrustOps.exportCircleOfTrust: end`);
+  return exportData;
 }
 
 /**
- * Export all circles of trust to individual files
+ * Export circles of trust
+ * @returns {Promise<CirclesOfTrustExportInterface>} a promise that resolves to an CirclesOfTrustExportInterface object
  */
-export async function exportCirclesOfTrustToFiles() {
-  let allCotData = [];
+export async function exportCirclesOfTrust({
+  state
+}) {
+  debugMessage(`CirclesOfTrustOps.exportCirclesOfTrust: start`);
+  const exportData = createCirclesOfTrustExportTemplate({
+    state
+  });
+  const errors = [];
   try {
-    allCotData = _.cloneDeep((await getCirclesOfTrust()).result);
-    createProgressIndicator(allCotData.length, 'Exporting circles of trust');
-    for (const cotData of allCotData) {
-      delete cotData._rev;
-      updateProgressIndicator(`Exporting circle of trust ${cotData._id}`);
-      const fileName = getTypedFilename(cotData._id, 'cot.saml');
-      const fileData = getFileDataTemplate();
-      // eslint-disable-next-line no-await-in-loop
-      await exportDependencies(cotData, fileData);
-      fileData.saml.cot[cotData._id] = cotData;
-      saveJsonToFile(fileData, fileName);
+    const cots = await getCirclesOfTrust({
+      state
+    });
+    for (const cot of cots) {
+      exportData.saml.cot[cot._id] = cot;
     }
-    stopProgressIndicator(`${allCotData.length} providers exported.`);
   } catch (error) {
-    printMessage(`getCirclesOfTrust ERROR: ${error}`, 'error');
-    printMessage(error, 'data');
+    errors.push(error);
   }
-}
-
-/**
- * Include dependencies from the import file
- * @param {Object} cotData Object representing a SAML circle of trust
- * @param {Object} fileData File data object to read dependencies from
- */
-async function importDependencies(cotData, fileData) {
-  // TODO: Import dependencies
-  return [cotData, fileData];
+  if (errors.length) {
+    const errorMessages = errors.map(error => error.message).join('\n');
+    throw new Error(`Export error:\n${errorMessages}`);
+  }
+  debugMessage(`CirclesOfTrustOps.exportCirclesOfTrust: end`);
+  return exportData;
 }
 
 /**
  * Import a SAML circle of trust by id/name from file
  * @param {String} cotId Circle of trust id/name
- * @param {String} file Import file name
+ * @param {CirclesOfTrustExportInterface} importData import data
  */
-export async function importCircleOfTrust(cotId, file) {
-  fs.readFile(file, 'utf8', async (err, data) => {
-    if (err) throw err;
-    const fileData = JSON.parse(data);
-    if (validateImport(fileData.meta)) {
-      createProgressIndicator(1, 'Importing circle of trust...');
-      const cotData = _.get(fileData, ['saml', 'cot', cotId]);
-      if (cotData) {
-        updateProgressIndicator(`Importing ${cotId}`);
-        await importDependencies(cotData, fileData);
+export async function importCircleOfTrust({
+  cotId,
+  importData,
+  state
+}) {
+  let response = null;
+  const errors = [];
+  const imported = [];
+  for (const id of Object.keys(importData.saml.cot)) {
+    if (id === cotId) {
+      try {
+        const cotData = importData.saml.cot[id];
+        delete cotData._rev;
         try {
-          await createCircleOfTrust(cotData);
-          stopProgressIndicator(`Successfully imported ${cotId}.`);
-        } catch (createProviderErr) {
-          stopProgressIndicator(`Error importing ${cotId}.`);
-          printMessage(`Error importing ${cotId}`, 'error');
-          printMessage(createProviderErr.response.data, 'error');
+          response = await createCircleOfTrust({
+            cotData,
+            state
+          });
+        } catch (createError) {
+          var _createError$response;
+          if (((_createError$response = createError.response) === null || _createError$response === void 0 ? void 0 : _createError$response.status) === 409) response = await updateCircleOfTrust({
+            cotId: id,
+            cotData,
+            state
+          });else throw createError;
         }
-      } else {
-        stopProgressIndicator(`Circle of trust ${cotId.brightCyan} not found in ${file.brightCyan}!`);
+        imported.push(id);
+      } catch (error) {
+        errors.push(error);
       }
-    } else {
-      printMessage('Import validation failed...', 'error');
     }
-  });
-}
-
-/**
- * Import first SAML circle of trust from file
- * @param {String} file Import file name
- */
-export async function importFirstCircleOfTrust(file) {
-  fs.readFile(file, 'utf8', async (err, data) => {
-    if (err) throw err;
-    const fileData = JSON.parse(data);
-    if (validateImport(fileData.meta)) {
-      createProgressIndicator(1, 'Importing circle of trust...');
-      for (const cotId in fileData.saml.cot) {
-        if ({}.hasOwnProperty.call(fileData.saml.cot, cotId)) {
-          const cotData = _.cloneDeep(fileData.saml.cot[cotId]);
-          updateProgressIndicator(`Importing ${cotId}`);
-          // eslint-disable-next-line no-await-in-loop
-          await importDependencies(cotData, fileData);
-          try {
-            await createCircleOfTrust(cotData);
-            stopProgressIndicator(`Successfully imported ${cotId}.`);
-          } catch (createCircleOfTrustErr) {
-            stopProgressIndicator(`Error importing ${cotId}.`);
-            printMessage(`Error importing ${cotId}`, 'error');
-            printMessage(createCircleOfTrustErr.response.data, 'error');
-          }
-          break;
-        }
-      }
-    } else {
-      printMessage('Import validation failed...', 'error');
-    }
-  });
+  }
+  if (errors.length) {
+    const errorMessages = errors.map(error => {
+      var _error$response3, _error$response3$data;
+      return ((_error$response3 = error.response) === null || _error$response3 === void 0 ? void 0 : (_error$response3$data = _error$response3.data) === null || _error$response3$data === void 0 ? void 0 : _error$response3$data.message) || error.message;
+    }).join('\n');
+    throw new Error(`Import error:\n${errorMessages}`);
+  }
+  if (0 === imported.length) {
+    throw new Error(`Import error:\n${cotId} not found in import data!`);
+  }
+  return response;
 }
 
 /**
- * Import all SAML circles of trust from file
- * @param {String} file Import file name
+ * Import first SAML circle of trust
+ * @param {CirclesOfTrustExportInterface} importData import data
  */
-export async function importCirclesOfTrustFromFile(file) {
-  fs.readFile(file, 'utf8', async (err, data) => {
-    if (err) throw err;
-    const fileData = JSON.parse(data);
-    if (validateImport(fileData.meta)) {
-      createProgressIndicator(Object.keys(fileData.saml.cot).length, 'Importing circles of trust...');
-      for (const cotId in fileData.saml.cot) {
-        if ({}.hasOwnProperty.call(fileData.saml.cot, cotId)) {
-          const cotData = _.cloneDeep(fileData.saml.cot[cotId]);
-          // eslint-disable-next-line no-await-in-loop
-          await importDependencies(cotData, fileData);
-          try {
-            // eslint-disable-next-line no-await-in-loop
-            await createCircleOfTrust(cotData);
-            updateProgressIndicator(`Imported ${cotId}`);
-          } catch (createCircleOfTrustErr) {
-            printMessage(`\nError importing ${cotId}`, 'error');
-            printMessage(createCircleOfTrustErr.response.data, 'error');
-          }
-        }
+export async function importFirstCircleOfTrust({
+  importData,
+  state
+}) {
+  let response = null;
+  const errors = [];
+  const imported = [];
+  for (const id of Object.keys(importData.saml.cot)) {
+    try {
+      const cotData = importData.saml.cot[id];
+      delete cotData._rev;
+      try {
+        response = await createCircleOfTrust({
+          cotData,
+          state
+        });
+      } catch (createError) {
+        var _createError$response2;
+        if (((_createError$response2 = createError.response) === null || _createError$response2 === void 0 ? void 0 : _createError$response2.status) === 409) response = await updateCircleOfTrust({
+          cotId: id,
+          cotData,
+          state
+        });else throw createError;
       }
-      stopProgressIndicator(`Circles of trust imported.`);
-    } else {
-      printMessage('Import validation failed...', 'error');
+      imported.push(id);
+    } catch (error) {
+      errors.push(error);
     }
-  });
+    break;
+  }
+  if (errors.length) {
+    const errorMessages = errors.map(error => {
+      var _error$response4, _error$response4$data;
+      return ((_error$response4 = error.response) === null || _error$response4 === void 0 ? void 0 : (_error$response4$data = _error$response4.data) === null || _error$response4$data === void 0 ? void 0 : _error$response4$data.message) || error.message;
+    }).join('\n');
+    throw new Error(`Import error:\n${errorMessages}`);
+  }
+  if (0 === imported.length) {
+    throw new Error(`Import error:\nNo circles of trust found in import data!`);
+  }
+  return response;
 }
 
 /**
- * Import all SAML circles of trust from all *.cot.saml.json files in the current directory
+ * Import SAML circles of trust
+ * @param {CirclesOfTrustExportInterface} importData import data
  */
-export async function importCirclesOfTrustFromFiles() {
-  const names = fs.readdirSync('.');
-  const jsonFiles = names.filter(name => name.toLowerCase().endsWith('.cot.saml.json'));
-  createProgressIndicator(jsonFiles.length, 'Importing circles or trust...');
-  let total = 0;
-  let totalErrors = 0;
-  for (const file of jsonFiles) {
-    const data = fs.readFileSync(file, 'utf8');
-    const fileData = JSON.parse(data);
-    if (validateImport(fileData.meta)) {
-      total += _.keys(fileData.saml.cot).length;
-      let errors = 0;
-      for (const cotId in fileData.saml.cot) {
-        if ({}.hasOwnProperty.call(fileData.saml.cot, cotId)) {
-          const cotData = _.cloneDeep(fileData.saml.cot[cotId]);
-          // eslint-disable-next-line no-await-in-loop
-          await importDependencies(cotData, fileData);
-          try {
-            // eslint-disable-next-line no-await-in-loop
-            await createCircleOfTrust(cotData);
-            // updateProgressIndicator(`Imported ${cotId}`);
-          } catch (createCircleOfTrustErr) {
-            errors += 1;
-            printMessage(`\nError importing ${cotId}`, 'error');
-            printMessage(createCircleOfTrustErr.response.data, 'error');
-          }
-        }
+export async function importCirclesOfTrust({
+  importData,
+  state
+}) {
+  const response = [];
+  const errors = [];
+  const imported = [];
+  for (const id of Object.keys(importData.saml.cot)) {
+    try {
+      const cotData = importData.saml.cot[id];
+      delete cotData._rev;
+      try {
+        response.push(await createCircleOfTrust({
+          cotData,
+          state
+        }));
+      } catch (createError) {
+        var _createError$response3;
+        if (((_createError$response3 = createError.response) === null || _createError$response3 === void 0 ? void 0 : _createError$response3.status) === 409) response.push(await updateCircleOfTrust({
+          cotId: id,
+          cotData,
+          state
+        }));else throw createError;
       }
-      totalErrors += errors;
-      updateProgressIndicator(`Imported ${_.keys(fileData.saml.cot).length - errors} circle(s) of trust from ${file}`);
-    } else {
-      printMessage(`Validation of ${file} failed!`, 'error');
+      imported.push(id);
+    } catch (error) {
+      errors.push(error);
     }
   }
-  stopProgressIndicator(`Imported ${total - totalErrors} of ${total} circle(s) of trust from ${jsonFiles.length} file(s).`);
+  if (errors.length) {
+    const errorMessages = errors.map(error => {
+      var _error$response5, _error$response5$data;
+      return ((_error$response5 = error.response) === null || _error$response5 === void 0 ? void 0 : (_error$response5$data = _error$response5.data) === null || _error$response5$data === void 0 ? void 0 : _error$response5$data.message) || error.message;
+    }).join('\n');
+    throw new Error(`Import error:\n${errorMessages}`);
+  }
+  if (0 === imported.length) {
+    throw new Error(`Import error:\nNo circles of trust found in import data!`);
+  }
+  return response;
 }
 //# sourceMappingURL=CirclesOfTrustOps.js.map