@rockcarver/frodo-lib 1.0.0 → 2.0.0-2

package/esm/ops/ConnectionProfileOps.mjs

@@ -1,15 +1,108 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import * as state from '../shared/State';
 import DataProtection from './utils/DataProtection';
-import { createObjectTable, createTable, debugMessage, printMessage, verboseMessage } from './utils/Console';
+import { debugMessage, printMessage, verboseMessage } from './utils/Console';
 import { FRODO_CONNECTION_PROFILES_PATH_KEY } from '../storage/StaticStorage';
 import { createJwkRsa, createJwks, getJwkRsaPublic } from './JoseOps';
 import { createServiceAccount, getServiceAccount } from './cloud/ServiceAccountOps';
 import { saveJsonToFile } from './utils/ExportImportUtils';
 import { isValidUrl } from './utils/OpsUtils';
-const crypto = new DataProtection();
+export default class ConnectionProfileOps {
+  constructor(state) {
+    this.state = state;
+  }
+
+  /**
+   * Get connection profiles file name
+   * @returns {string} connection profiles file name
+   */
+  getConnectionProfilesPath() {
+    return getConnectionProfilesPath({
+      state: this.state
+    });
+  }
+
+  /**
+   * Find connection profiles
+   * @param {ConnectionsFileInterface} connectionProfiles connection profile object
+   * @param {string} host host url or unique substring
+   * @returns {SecureConnectionProfileInterface[]} Array of connection profiles
+   */
+  findConnectionProfiles(connectionProfiles, host) {
+    return findConnectionProfiles({
+      connectionProfiles,
+      host
+    });
+  }
+
+  /**
+   * Initialize connection profiles
+   *
+   * This method is called from app.ts and runs before any of the message handlers are registered.
+   * Therefore none of the Console message functions will produce any output.
+   */
+  async initConnectionProfiles() {
+    initConnectionProfiles({
+      state: this.state
+    });
+  }
+
+  /**
+   * Get connection profile by host
+   * @param {String} host host tenant host url or unique substring
+   * @returns {Object} connection profile or null
+   */
+  async getConnectionProfileByHost(host) {
+    return getConnectionProfileByHost({
+      host,
+      state: this.state
+    });
+  }
+
+  /**
+   * Get connection profile
+   * @returns {Object} connection profile or null
+   */
+  async getConnectionProfile() {
+    return getConnectionProfile({
+      state: this.state
+    });
+  }
+
+  /**
+   * Save connection profile
+   * @param {string} host host url for new profiles or unique substring for existing profiles
+   * @returns {Promise<boolean>} true if the operation succeeded, false otherwise
+   */
+  async saveConnectionProfile(host) {
+    return saveConnectionProfile({
+      host,
+      state: this.state
+    });
+  }
+
+  /**
+   * Delete connection profile
+   * @param {string} host host tenant host url or unique substring
+   */
+  deleteConnectionProfile(host) {
+    deleteConnectionProfile({
+      host,
+      state: this.state
+    });
+  }
+
+  /**
+   * Create a new service account using auto-generated parameters
+   * @returns {Promise<IdObjectSkeletonInterface>} A promise resolving to a service account object
+   */
+  async addNewServiceAccount() {
+    return addNewServiceAccount({
+      state: this.state
+    });
+  }
+}
 const fileOptions = {
   indentation: 4
 };
@@ -18,9 +111,12 @@ const newProfileFilename = 'Connections.json';
 
 /**
  * Get connection profiles file name
+ * @param {State} state library state
  * @returns {String} connection profiles file name
  */
-export function getConnectionProfilesPath() {
+export function getConnectionProfilesPath({
+  state
+}) {
   return state.getConnectionProfilesPath() || process.env[FRODO_CONNECTION_PROFILES_PATH_KEY] || `${os.homedir()}/.frodo/${newProfileFilename}`;
 }
 
@@ -28,9 +124,13 @@ export function getConnectionProfilesPath() {
  * Find connection profiles
  * @param {ConnectionsFileInterface} connectionProfiles connection profile object
  * @param {string} host host url or unique substring
+ * @param {State} state library state
  * @returns {SecureConnectionProfileInterface[]} Array of connection profiles
  */
-function findConnectionProfiles(connectionProfiles, host) {
+function findConnectionProfiles({
+  connectionProfiles,
+  host
+}) {
   const profiles = [];
   for (const tenant in connectionProfiles) {
     debugMessage(`ConnectionProfileOps.findConnectionProfiles: tenant=${tenant}`);
@@ -46,38 +146,6 @@ function findConnectionProfiles(connectionProfiles, host) {
   return profiles;
 }
 
-/**
- * List connection profiles
- * @param {boolean} long Long list format with details
- */
-export function listConnectionProfiles(long = false) {
-  const filename = getConnectionProfilesPath();
-  try {
-    const data = fs.readFileSync(filename, 'utf8');
-    const connectionsData = JSON.parse(data);
-    if (Object.keys(connectionsData).length < 1) {
-      printMessage(`No connections defined yet in ${filename}`, 'info');
-    } else {
-      if (long) {
-        const table = createTable(['Host', 'Service Account', 'Username', 'Log API Key']);
-        Object.keys(connectionsData).forEach(c => {
-          table.push([c, connectionsData[c].svcacctName || connectionsData[c].svcacctId, connectionsData[c].username, connectionsData[c].logApiKey]);
-        });
-        printMessage(table.toString(), 'data');
-      } else {
-        Object.keys(connectionsData).forEach(c => {
-          printMessage(`${c}`, 'data');
-        });
-        // getUniqueNames(5, Object.keys(connectionsData));
-      }
-
-      printMessage('Any unique substring of a saved host can be used as the value for host parameter in all commands', 'info');
-    }
-  } catch (e) {
-    printMessage(`No connections found in ${filename} (${e.message})`, 'error');
-  }
-}
-
 /**
  * Migrate from .frodorc to Connections.json
  */
@@ -103,10 +171,16 @@ function migrateFromLegacyProfile() {
  *
  * This method is called from app.ts and runs before any of the message handlers are registered.
  * Therefore none of the Console message functions will produce any output.
+ * @param {State} state library state
  */
-export async function initConnectionProfiles() {
+export async function initConnectionProfiles({
+  state
+}) {
+  const dataProtection = new DataProtection(state.getMasterKeyPath());
   // create connections.json file if it doesn't exist
-  const filename = getConnectionProfilesPath();
+  const filename = getConnectionProfilesPath({
+    state
+  });
   const folderName = path.dirname(filename);
   if (!fs.existsSync(folderName)) {
     fs.mkdirSync(folderName, {
@@ -125,17 +199,17 @@ export async function initConnectionProfiles() {
     for (const conn of Object.keys(connectionsData)) {
       if (connectionsData[conn]['password']) {
         convert = true;
-        connectionsData[conn].encodedPassword = await crypto.encrypt(connectionsData[conn]['password']);
+        connectionsData[conn].encodedPassword = await dataProtection.encrypt(connectionsData[conn]['password']);
         delete connectionsData[conn]['password'];
       }
       if (connectionsData[conn]['logApiSecret']) {
         convert = true;
-        connectionsData[conn].encodedLogApiSecret = await crypto.encrypt(connectionsData[conn]['logApiSecret']);
+        connectionsData[conn].encodedLogApiSecret = await dataProtection.encrypt(connectionsData[conn]['logApiSecret']);
         delete connectionsData[conn]['logApiSecret'];
       }
       if (connectionsData[conn]['svcacctJwk']) {
         convert = true;
-        connectionsData[conn].encodedSvcacctJwk = await crypto.encrypt(connectionsData[conn]['svcacctJwk']);
+        connectionsData[conn].encodedSvcacctJwk = await dataProtection.encrypt(connectionsData[conn]['svcacctJwk']);
         delete connectionsData[conn]['svcacctJwk'];
       }
     }
@@ -148,13 +222,23 @@ export async function initConnectionProfiles() {
 /**
  * Get connection profile by host
  * @param {String} host host tenant host url or unique substring
+ * @param {State} state library state
  * @returns {Object} connection profile or null
  */
-export async function getConnectionProfileByHost(host) {
+export async function getConnectionProfileByHost({
+  host,
+  state
+}) {
   try {
-    const filename = getConnectionProfilesPath();
+    const dataProtection = new DataProtection(state.getMasterKeyPath());
+    const filename = getConnectionProfilesPath({
+      state
+    });
     const connectionsData = JSON.parse(fs.readFileSync(filename, 'utf8'));
-    const profiles = findConnectionProfiles(connectionsData, host);
+    const profiles = findConnectionProfiles({
+      connectionProfiles: connectionsData,
+      host
+    });
     if (profiles.length == 0) {
       printMessage(`Profile for ${host} not found. Please specify credentials on command line`, 'error');
       return null;
@@ -170,14 +254,14 @@ export async function getConnectionProfileByHost(host) {
     return {
       tenant: profiles[0].tenant,
       username: profiles[0].username ? profiles[0].username : null,
-      password: profiles[0].encodedPassword ? await crypto.decrypt(profiles[0].encodedPassword) : null,
+      password: profiles[0].encodedPassword ? await dataProtection.decrypt(profiles[0].encodedPassword) : null,
       logApiKey: profiles[0].logApiKey ? profiles[0].logApiKey : null,
-      logApiSecret: profiles[0].encodedLogApiSecret ? await crypto.decrypt(profiles[0].encodedLogApiSecret) : null,
+      logApiSecret: profiles[0].encodedLogApiSecret ? await dataProtection.decrypt(profiles[0].encodedLogApiSecret) : null,
       authenticationService: profiles[0].authenticationService ? profiles[0].authenticationService : null,
       authenticationHeaderOverrides: profiles[0].authenticationHeaderOverrides ? profiles[0].authenticationHeaderOverrides : {},
       svcacctName: profiles[0].svcacctName ? profiles[0].svcacctName : null,
       svcacctId: profiles[0].svcacctId ? profiles[0].svcacctId : null,
-      svcacctJwk: profiles[0].encodedSvcacctJwk ? await crypto.decrypt(profiles[0].encodedSvcacctJwk) : null
+      svcacctJwk: profiles[0].encodedSvcacctJwk ? await dataProtection.decrypt(profiles[0].encodedSvcacctJwk) : null
     };
   } catch (e) {
     printMessage(`Can not read saved connection info, please specify credentials on command line: ${e}`, 'error');
@@ -189,8 +273,13 @@ export async function getConnectionProfileByHost(host) {
  * Get connection profile
  * @returns {Object} connection profile or null
  */
-export async function getConnectionProfile() {
-  return getConnectionProfileByHost(state.getHost());
+export async function getConnectionProfile({
+  state
+}) {
+  return getConnectionProfileByHost({
+    host: state.getHost(),
+    state
+  });
 }
 
 /**
@@ -198,9 +287,15 @@ export async function getConnectionProfile() {
  * @param {string} host host url for new profiles or unique substring for existing profiles
  * @returns {Promise<boolean>} true if the operation succeeded, false otherwise
  */
-export async function saveConnectionProfile(host) {
+export async function saveConnectionProfile({
+  host,
+  state
+}) {
   debugMessage(`ConnectionProfileOps.saveConnectionProfile: start`);
-  const filename = getConnectionProfilesPath();
+  const dataProtection = new DataProtection(state.getMasterKeyPath());
+  const filename = getConnectionProfilesPath({
+    state
+  });
   debugMessage(`Saving connection profile in ${filename}`);
   let profiles = {};
   let profile = {
@@ -212,7 +307,10 @@ export async function saveConnectionProfile(host) {
     profiles = JSON.parse(data);
 
     // find tenant
-    const found = findConnectionProfiles(profiles, host);
+    const found = findConnectionProfiles({
+      connectionProfiles: profiles,
+      host
+    });
 
     // replace tenant in session with real tenant url if necessary
     if (found.length === 1) {
@@ -239,21 +337,27 @@ export async function saveConnectionProfile(host) {
 
   // user account
   if (state.getUsername()) profile.username = state.getUsername();
-  if (state.getPassword()) profile.encodedPassword = await crypto.encrypt(state.getPassword());
+  if (state.getPassword()) profile.encodedPassword = await dataProtection.encrypt(state.getPassword());
 
   // log API
   if (state.getLogApiKey()) profile.logApiKey = state.getLogApiKey();
-  if (state.getLogApiSecret()) profile.encodedLogApiSecret = await crypto.encrypt(state.getLogApiSecret());
+  if (state.getLogApiSecret()) profile.encodedLogApiSecret = await dataProtection.encrypt(state.getLogApiSecret());
 
   // service account
   if (state.getServiceAccountId()) {
     profile.svcacctId = state.getServiceAccountId();
-    profile.svcacctName = (await getServiceAccount(state.getServiceAccountId())).name;
+    profile.svcacctName = (await getServiceAccount({
+      serviceAccountId: state.getServiceAccountId(),
+      state
+    })).name;
   }
-  if (state.getServiceAccountJwk()) profile.encodedSvcacctJwk = await crypto.encrypt(state.getServiceAccountJwk());
+  if (state.getServiceAccountJwk()) profile.encodedSvcacctJwk = await dataProtection.encrypt(state.getServiceAccountJwk());
   // update existing service account profile
   if (profile.svcacctId && !profile.svcacctName) {
-    profile.svcacctName = (await getServiceAccount(profile.svcacctId)).name;
+    profile.svcacctName = (await getServiceAccount({
+      serviceAccountId: profile.svcacctId,
+      state
+    })).name;
     debugMessage(`ConnectionProfileOps.saveConnectionProfile: added missing service account name`);
   }
 
@@ -281,7 +385,12 @@ export async function saveConnectionProfile(host) {
   }, {});
 
   // save profiles
-  saveJsonToFile(orderedProfiles, filename, false);
+  saveJsonToFile({
+    data: orderedProfiles,
+    filename,
+    includeMeta: false,
+    state
+  });
   verboseMessage(`Saved connection profile ${state.getHost()} in ${filename}`);
   debugMessage(`ConnectionProfileOps.saveConnectionProfile: end [true]`);
   return true;
@@ -291,14 +400,22 @@ export async function saveConnectionProfile(host) {
  * Delete connection profile
  * @param {String} host host tenant host url or unique substring
  */
-export function deleteConnectionProfile(host) {
-  const filename = getConnectionProfilesPath();
+export function deleteConnectionProfile({
+  host,
+  state
+}) {
+  const filename = getConnectionProfilesPath({
+    state
+  });
   let connectionsData = {};
   fs.stat(filename, err => {
     if (err == null) {
       const data = fs.readFileSync(filename, 'utf8');
       connectionsData = JSON.parse(data);
-      const profiles = findConnectionProfiles(connectionsData, host);
+      const profiles = findConnectionProfiles({
+        connectionProfiles: connectionsData,
+        host
+      });
       if (profiles.length == 1) {
         delete connectionsData[profiles[0].tenant];
         fs.writeFileSync(filename, JSON.stringify(connectionsData, null, 2));
@@ -323,70 +440,13 @@ export function deleteConnectionProfile(host) {
   });
 }
 
-/**
- * Describe connection profile
- * @param {string} host Host URL or unique substring
- * @param {boolean} showSecrets Whether secrets should be shown in clear text or not
- */
-export async function describeConnectionProfile(host, showSecrets) {
-  debugMessage(`ConnectionProfileOps.describeConnectionProfile: start`);
-  const profile = await getConnectionProfileByHost(host);
-  if (profile) {
-    debugMessage(profile);
-    const present = '[present]';
-    const jwk = profile.svcacctJwk;
-    if (!showSecrets) {
-      if (profile.password) profile.password = present;
-      if (profile.logApiSecret) profile.logApiSecret = present;
-      if (profile.svcacctJwk) profile['svcacctJwk'] = present;
-    }
-    if (!profile.username) {
-      delete profile.username;
-      delete profile.password;
-    }
-    if (!profile.logApiKey) {
-      delete profile.logApiKey;
-      delete profile.logApiSecret;
-    }
-    if (!profile.svcacctId) {
-      delete profile.svcacctId;
-      delete profile.svcacctJwk;
-      delete profile.svcacctName;
-    }
-    if (showSecrets && jwk) {
-      profile['svcacctJwk'] = 'see below';
-    }
-    if (!profile.authenticationService) {
-      delete profile.authenticationService;
-    }
-    const keyMap = {
-      tenant: 'Host',
-      username: 'Username',
-      password: 'Password',
-      logApiKey: 'Log API Key',
-      logApiSecret: 'Log API Secret',
-      authenticationService: 'Authentication Service',
-      authenticationHeaderOverrides: 'Authentication Header Overrides',
-      svcacctName: 'Service Account Name',
-      svcacctId: 'Service Account Id',
-      svcacctJwk: 'Service Account JWK'
-    };
-    const table = createObjectTable(profile, keyMap);
-    printMessage(table.toString(), 'data');
-    if (showSecrets && jwk) {
-      printMessage(jwk, 'data');
-    }
-  } else {
-    printMessage(`No connection profile ${host} found`);
-  }
-  debugMessage(`ConnectionProfileOps.describeConnectionProfile: end`);
-}
-
 /**
  * Create a new service account using auto-generated parameters
  * @returns {Promise<IdObjectSkeletonInterface>} A promise resolving to a service account object
  */
-export async function addNewServiceAccount() {
+export async function addNewServiceAccount({
+  state
+}) {
   debugMessage(`ConnectionProfileOps.addNewServiceAccount: start`);
   const name = `Frodo-SA-${new Date().getTime()}`;
   debugMessage(`ConnectionProfileOps.addNewServiceAccount: name=${name}...`);
@@ -395,7 +455,14 @@ export async function addNewServiceAccount() {
   const jwkPrivate = await createJwkRsa();
   const jwkPublic = await getJwkRsaPublic(jwkPrivate);
   const jwks = createJwks(jwkPublic);
-  const sa = await createServiceAccount(name, description, 'Active', scope, jwks);
+  const sa = await createServiceAccount({
+    name,
+    description,
+    accountStatus: 'Active',
+    scopes: scope,
+    jwks,
+    state
+  });
   debugMessage(`ConnectionProfileOps.addNewServiceAccount: id=${sa._id}`);
   state.setServiceAccountId(sa._id);
   state.setServiceAccountJwk(jwkPrivate);

package/esm/ops/ConnectionProfileOps.test.mjs

@@ -1,6 +1,15 @@
+/**
+ * Run tests
+ *
+ *        npm run test:only ConnectionProfileOps
+ *
+ * Note: FRODO_DEBUG=1 is optional and enables debug logging for some output
+ * in case things don't function as expected
+ */
 import fs from 'fs';
 import { homedir } from 'os';
-import { ConnectionProfile, state } from '../index';
+import { state } from '../index';
+import * as ConnectionProfileOps from './ConnectionProfileOps';
 import { FRODO_CONNECTION_PROFILES_PATH_KEY, FRODO_MASTER_KEY_PATH_KEY, FRODO_MASTER_KEY_KEY } from '../storage/StaticStorage';
 describe('ConnectionProfileOps', () => {
   const connectionProfilePath1 = `${homedir()}/connections1.json`;
@@ -53,7 +62,10 @@ describe('ConnectionProfileOps', () => {
       state.setUsername(user);
       state.setPassword(password);
       state.setConnectionProfilesPath(connectionProfilePath1);
-      await ConnectionProfile.saveConnectionProfile(host);
+      await ConnectionProfileOps.saveConnectionProfile({
+        host,
+        state
+      });
       expect(fs.existsSync(connectionProfilePath1)).toBeTruthy();
       const connections = JSON.parse(fs.readFileSync(connectionProfilePath1, 'utf8'));
       expect(connections).toBeTruthy();
@@ -71,8 +83,13 @@ describe('ConnectionProfileOps', () => {
       state.setUsername(user);
       state.setPassword(password);
       state.setConnectionProfilesPath('');
-      await ConnectionProfile.saveConnectionProfile(host);
-      expect(ConnectionProfile.getConnectionProfilesPath()).toEqual(connectionProfilePath2);
+      await ConnectionProfileOps.saveConnectionProfile({
+        host,
+        state
+      });
+      expect(ConnectionProfileOps.getConnectionProfilesPath({
+        state
+      })).toEqual(connectionProfilePath2);
       expect(fs.existsSync(connectionProfilePath2)).toBeTruthy();
       const connections = JSON.parse(fs.readFileSync(connectionProfilePath2, 'utf8'));
       expect(connections).toBeTruthy();
@@ -91,7 +108,10 @@ describe('ConnectionProfileOps', () => {
       state.setUsername(user);
       state.setPassword(password);
       state.setConnectionProfilesPath(connectionProfilePath3);
-      await ConnectionProfile.saveConnectionProfile(host);
+      await ConnectionProfileOps.saveConnectionProfile({
+        host,
+        state
+      });
       expect(fs.existsSync(connectionProfilePath3)).toBeTruthy();
       const connections = JSON.parse(fs.readFileSync(connectionProfilePath3, 'utf8'));
       expect(connections).toBeTruthy();

package/esm/ops/EmailTemplateOps.mjs

@@ -1,4 +1,45 @@
 import { getConfigEntitiesByType, getConfigEntity, putConfigEntity } from '../api/IdmConfigApi';
+export default class EmailTemplateOps {
+  constructor(state) {
+    this.state = state;
+  }
+
+  /**
+   * Get all email templates
+   * @returns {Promise} a promise that resolves to an array of email template objects
+   */
+  async getEmailTemplates() {
+    return getEmailTemplates({
+      state: this.state
+    });
+  }
+
+  /**
+   * Get email template
+   * @param {string} templateId id/name of the email template without the type prefix
+   * @returns {Promise} a promise that resolves an email template object
+   */
+  async getEmailTemplate(templateId) {
+    return getEmailTemplate({
+      templateId,
+      state: this.state
+    });
+  }
+
+  /**
+   * Put email template
+   * @param {string} templateId id/name of the email template without the type prefix
+   * @param {Object} templateData email template object
+   * @returns {Promise} a promise that resolves to an email template object
+   */
+  async putEmailTemplate(templateId, templateData) {
+    return putEmailTemplate({
+      templateId,
+      templateData,
+      state: this.state
+    });
+  }
+}
 
 /**
  * Email template type key used to build the IDM id: 'emailTemplate/<id>'
@@ -9,8 +50,13 @@ export const EMAIL_TEMPLATE_TYPE = 'emailTemplate';
  * Get all email templates
  * @returns {Promise} a promise that resolves to an array of email template objects
  */
-export async function getEmailTemplates() {
-  return getConfigEntitiesByType(EMAIL_TEMPLATE_TYPE);
+export async function getEmailTemplates({
+  state
+}) {
+  return getConfigEntitiesByType({
+    type: EMAIL_TEMPLATE_TYPE,
+    state
+  });
 }
 
 /**
@@ -18,8 +64,14 @@ export async function getEmailTemplates() {
  * @param {string} templateId id/name of the email template without the type prefix
  * @returns {Promise} a promise that resolves an email template object
  */
-export async function getEmailTemplate(templateId) {
-  return getConfigEntity(`${EMAIL_TEMPLATE_TYPE}/${templateId}`);
+export async function getEmailTemplate({
+  templateId,
+  state
+}) {
+  return getConfigEntity({
+    entityId: `${EMAIL_TEMPLATE_TYPE}/${templateId}`,
+    state
+  });
 }
 
 /**
@@ -28,7 +80,15 @@ export async function getEmailTemplate(templateId) {
  * @param {Object} templateData email template object
  * @returns {Promise} a promise that resolves to an email template object
  */
-export async function putEmailTemplate(templateId, templateData) {
-  return putConfigEntity(`${EMAIL_TEMPLATE_TYPE}/${templateId}`, templateData);
+export async function putEmailTemplate({
+  templateId,
+  templateData,
+  state
+}) {
+  return putConfigEntity({
+    entityId: `${EMAIL_TEMPLATE_TYPE}/${templateId}`,
+    entityData: templateData,
+    state
+  });
 }
 //# sourceMappingURL=EmailTemplateOps.js.map