@rockcarver/frodo-lib 0.19.2 → 2.0.0-1

package/esm/ops/cloud/SecretsOps.mjs

@@ -1,227 +1,146 @@
-import { createKeyValueTable, createProgressIndicator, createTable, printMessage, stopProgressIndicator, updateProgressIndicator } from '../utils/Console';
-import { createNewVersionOfSecret, deleteSecret, deleteVersionOfSecret, getSecret, getSecrets, getSecretVersions, putSecret, setSecretDescription, setStatusOfVersionOfSecret, VersionOfSecretStatus } from '../../api/cloud/SecretsApi';
-import wordwrap from '../utils/Wordwrap';
-import { resolveUserName } from '../ManagedObjectOps';
-
-/**
- * List secrets
- * @param {boolean} long Long version, all the fields
- */
-export async function listSecrets(long) {
-  let secrets = [];
-  try {
-    secrets = (await getSecrets()).result;
-    secrets.sort((a, b) => a._id.localeCompare(b._id));
-  } catch (error) {
-    printMessage(`${error.message}`, 'error');
-    printMessage(error.response.data, 'error');
+import { createNewVersionOfSecret, deleteSecret, deleteVersionOfSecret, getSecret, getSecrets, getSecretVersions, getVersionOfSecret, putSecret, setSecretDescription, setStatusOfVersionOfSecret } from '../../api/cloud/SecretsApi';
+export default class SecretsOps {
+  constructor(state) {
+    this.state = state;
   }
-  if (long) {
-    const table = createTable(['Id'['brightCyan'], {
-      hAlign: 'right',
-      content: 'Active\nVersion'['brightCyan']
-    }, {
-      hAlign: 'right',
-      content: 'Loaded\nVersion'['brightCyan']
-    }, 'Status'['brightCyan'], 'Description'['brightCyan'], 'Modifier'['brightCyan'], 'Modified'['brightCyan']]);
-    for (const secret of secrets) {
-      table.push([secret._id, {
-        hAlign: 'right',
-        content: secret.activeVersion
-      }, {
-        hAlign: 'right',
-        content: secret.loadedVersion
-      }, secret.loaded ? 'loaded'['brightGreen'] : 'unloaded'['brightRed'], wordwrap(secret.description, 40),
-      // eslint-disable-next-line no-await-in-loop
-      await resolveUserName('teammember', secret.lastChangedBy), new Date(secret.lastChangeDate).toLocaleString()]);
-    }
-    printMessage(table.toString(), 'data');
-  } else {
-    secrets.forEach(secret => {
-      printMessage(secret._id, 'data');
+
+  /**
+   * Get all secrets
+   * @returns {Promise<unknown[]>} a promise that resolves to an array of secrets
+   */
+  async getSecrets() {
+    return getSecrets({
+      state: this.state
     });
   }
-}
 
-/**
- * Create secret
- * @param {String} id secret id
- * @param {String} value secret value
- * @param {String} description secret description
- * @param {String} encoding secret encoding
- * @param {boolean} useInPlaceholders use secret in placeholders
- */
-export async function createSecret(id, value, description, encoding, useInPlaceholders) {
-  createProgressIndicator(undefined, `Creating secret ${id}...`, 'indeterminate');
-  try {
-    await putSecret(id, value, description, encoding, useInPlaceholders);
-    stopProgressIndicator(`Created secret ${id}`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
+  /**
+   * Get secret
+   * @param secretId secret id/name
+   * @returns {Promise<unknown>} a promise that resolves to a secret
+   */
+  async getSecret(secretId) {
+    return getSecret({
+      secretId,
+      state: this.state
+    });
   }
-}
 
-/**
- * Set description of secret
- * @param {String} secretId secret id
- * @param {String} description secret description
- */
-export async function setDescriptionOfSecret(secretId, description) {
-  createProgressIndicator(undefined, `Setting description of secret ${secretId}...`, 'indeterminate');
-  try {
-    await setSecretDescription(secretId, description);
-    stopProgressIndicator(`Set description of secret ${secretId}`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
+  /**
+   * Create secret
+   * @param {string} secretId secret id/name
+   * @param {string} value secret value
+   * @param {string} description secret description
+   * @param {string} encoding secret encoding (only `generic` is supported)
+   * @param {boolean} useInPlaceholders flag indicating if the secret can be used in placeholders
+   * @returns {Promise<unknown>} a promise that resolves to a secret
+   */
+  async putSecret(secretId, value, description, encoding = 'generic', useInPlaceholders = true) {
+    return putSecret({
+      secretId,
+      value,
+      description,
+      encoding,
+      useInPlaceholders,
+      state: this.state
+    });
   }
-}
 
-/**
- * Delete a secret
- * @param {String} secretId secret id
- */
-export async function deleteSecretCmd(secretId) {
-  createProgressIndicator(undefined, `Deleting secret ${secretId}...`, 'indeterminate');
-  try {
-    await deleteSecret(secretId);
-    stopProgressIndicator(`Deleted secret ${secretId}`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
+  /**
+   * Set secret description
+   * @param {string} secretId secret id/name
+   * @param {string} description secret description
+   * @returns {Promise<unknown>} a promise that resolves to a status object
+   */
+  async setSecretDescription(secretId, description) {
+    return setSecretDescription({
+      secretId,
+      description,
+      state: this.state
+    });
   }
-}
 
-/**
- * Delete all secrets
- */
-export async function deleteSecretsCmd() {
-  try {
-    const secrets = (await getSecrets()).result;
-    createProgressIndicator(secrets.length, `Deleting secrets...`);
-    for (const secret of secrets) {
-      try {
-        // eslint-disable-next-line no-await-in-loop
-        await deleteSecret(secret._id);
-        updateProgressIndicator(`Deleted secret ${secret._id}`);
-      } catch (error) {
-        printMessage(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'error');
-      }
-    }
-    stopProgressIndicator(`Secrets deleted.`);
-  } catch (error) {
-    printMessage(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'error');
+  /**
+   * Delete secret
+   * @param {string} secretId secret id/name
+   * @returns {Promise<unknown>} a promise that resolves to a secret object
+   */
+  async deleteSecret(secretId) {
+    return deleteSecret({
+      secretId,
+      state: this.state
+    });
   }
-}
 
-/**
- * List all the versions of the secret
- * @param {String} secretId secret id
- */
-export async function listSecretVersionsCmd(secretId) {
-  let versions = [];
-  try {
-    versions = await getSecretVersions(secretId);
-  } catch (error) {
-    printMessage(`${error.message}`, 'error');
-    printMessage(error.response.data, 'error');
-  }
-  const table = createTable([{
-    hAlign: 'right',
-    content: 'Version'['brightCyan']
-  }, 'Status'['brightCyan'], 'Loaded'['brightCyan'], 'Created'['brightCyan']]);
-  // versions.sort((a, b) => a._id.localeCompare(b._id));
-  const statusMap = {
-    ENABLED: 'active'['brightGreen'],
-    DISABLED: 'inactive'['brightRed'],
-    DESTROYED: 'deleted'['brightRed']
-  };
-  for (const version of versions) {
-    table.push([{
-      hAlign: 'right',
-      content: version.version
-    }, statusMap[version.status], version.loaded ? 'loaded'['brightGreen'] : 'unloaded'['brightRed'], new Date(version.createDate).toLocaleString()]);
+  /**
+   * Get secret versions
+   * @param {string} secretId secret id/name
+   * @returns {Promise<unknown>} a promise that resolves to an array of secret versions
+   */
+  async getSecretVersions(secretId) {
+    return getSecretVersions({
+      secretId,
+      state: this.state
+    });
   }
-  printMessage(table.toString());
-}
-
-/**
- * Describe a secret
- * @param {String} secretId Secret id
- */
-export async function describeSecret(secretId) {
-  const secret = await getSecret(secretId);
-  const table = createKeyValueTable();
-  table.push(['Name'['brightCyan'], secret._id]);
-  table.push(['Active Version'['brightCyan'], secret.activeVersion]);
-  table.push(['Loaded Version'['brightCyan'], secret.loadedVersion]);
-  table.push(['Status'['brightCyan'], secret.loaded ? 'loaded'['brightGreen'] : 'unloaded'['brightRed']]);
-  table.push(['Description'['brightCyan'], wordwrap(secret.description, 60)]);
-  table.push(['Modified'['brightCyan'], new Date(secret.lastChangeDate).toLocaleString()]);
-  table.push(['Modifier'['brightCyan'], await resolveUserName('teammember', secret.lastChangedBy)]);
-  table.push(['Modifier UUID'['brightCyan'], secret.lastChangedBy]);
-  table.push(['Encoding'['brightCyan'], secret.encoding]);
-  table.push(['Use In Placeholders'['brightCyan'], secret.useInPlaceholders]);
-  printMessage(table.toString());
-  printMessage('\nSecret Versions:');
-  await listSecretVersionsCmd(secretId);
-}
 
-/**
- * Create new version of secret
- * @param {String} secretId secret id
- * @param {String} value secret value
- */
-export async function createNewVersionOfSecretCmd(secretId, value) {
-  createProgressIndicator(undefined, `Creating new version of secret ${secretId}...`, 'indeterminate');
-  try {
-    const version = await createNewVersionOfSecret(secretId, value);
-    stopProgressIndicator(`Created version ${version.version} of secret ${secretId}`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
+  /**
+   * Create new secret version
+   * @param {string} secretId secret id/name
+   * @param {string} value secret value
+   * @returns {Promise<unknown>} a promise that resolves to a version object
+   */
+  async createNewVersionOfSecret(secretId, value) {
+    return createNewVersionOfSecret({
+      secretId,
+      value,
+      state: this.state
+    });
   }
-}
 
-/**
- * Activate a version of a secret
- * @param {String} secretId secret id
- * @param {Number} version version of secret
- */
-export async function activateVersionOfSecret(secretId, version) {
-  createProgressIndicator(undefined, `Activating version ${version} of secret ${secretId}...`, 'indeterminate');
-  try {
-    await setStatusOfVersionOfSecret(secretId, version, VersionOfSecretStatus.ENABLED);
-    stopProgressIndicator(`Activated version ${version} of secret ${secretId}`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
+  /**
+   * Get version of secret
+   * @param {string} secretId secret id/name
+   * @param {string} version secret version
+   * @returns {Promise<unknown>} a promise that resolves to a version object
+   */
+  async getVersionOfSecret(secretId, version) {
+    return getVersionOfSecret({
+      secretId,
+      version,
+      state: this.state
+    });
   }
-}
 
-/**
- * Deactivate a version of a secret
- * @param {String} secretId secret id
- * @param {Number} version version of secret
- */
-export async function deactivateVersionOfSecret(secretId, version) {
-  createProgressIndicator(undefined, `Deactivating version ${version} of secret ${secretId}...`, 'indeterminate');
-  try {
-    await setStatusOfVersionOfSecret(secretId, version, VersionOfSecretStatus.DISABLED);
-    stopProgressIndicator(`Deactivated version ${version} of secret ${secretId}`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
+  /**
+   * Update the status of a version of a secret
+   * @param {string} secretId secret id/name
+   * @param {string} version secret version
+   * @param {VersionOfSecretStatus} status status
+   * @returns {Promise<unknown>} a promise that resolves to a status object
+   */
+  async setStatusOfVersionOfSecret(secretId, version, status) {
+    return setStatusOfVersionOfSecret({
+      secretId,
+      version,
+      status,
+      state: this.state
+    });
   }
-}
 
-/**
- * Delete version of secret
- * @param {String} secretId secret id
- * @param {Number} version version of secret
- */
-export async function deleteVersionOfSecretCmd(secretId, version) {
-  createProgressIndicator(undefined, `Deleting version ${version} of secret ${secretId}...`, 'indeterminate');
-  try {
-    await deleteVersionOfSecret(secretId, version);
-    stopProgressIndicator(`Deleted version ${version} of secret ${secretId}`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
+  /**
+   * Delete version of secret
+   * @param {string} secretId secret id/name
+   * @param {string} version secret version
+   * @returns {Promise<unknown>} a promise that resolves to a version object
+   */
+  async deleteVersionOfSecret(secretId, version) {
+    return deleteVersionOfSecret({
+      secretId,
+      version,
+      state: this.state
+    });
   }
 }
+export { createNewVersionOfSecret, deleteSecret, deleteVersionOfSecret, getSecret, getSecrets, getSecretVersions, putSecret, setSecretDescription, setStatusOfVersionOfSecret };
 //# sourceMappingURL=SecretsOps.js.map

package/esm/ops/cloud/ServiceAccountOps.mjs

@@ -1,23 +1,69 @@
 import { createManagedObject, getManagedObject } from '../../api/ManagedObjectApi';
 import { debugMessage } from '../utils/Console';
 import { hasFeature } from './FeatureOps';
-const moType = 'svcacct';
-/**
- * Global flag indicating if service accounts are available
- */
-let _featureAvailable = undefined;
+import { getTenantURL } from '../../api/utils/ApiUtils';
+export default class ServiceAccountOps {
+  constructor(state) {
+    this.state = state;
+  }
+
+  /**
+   * Check if service accounts are available
+   * @returns {Promise<boolean>} true if service accounts are available, false otherwise
+   */
+  async isServiceAccountsFeatureAvailable() {
+    return isServiceAccountsFeatureAvailable({
+      state: this.state
+    });
+  }
+
+  /**
+   * Create service account
+   * @param {string} name Human-readable name of service account
+   * @param {string} description Description of service account
+   * @param {'Active' | 'Inactive'} accountStatus Service account status
+   * @param {string[]} scopes Scopes.
+   * @param {JwksInterface} jwks Java Web Key Set
+   * @returns {Promise<IdObjectSkeletonInterface>} A promise resolving to a service account object
+   */
+  async createServiceAccount(name, description, accountStatus, scopes, jwks) {
+    return createServiceAccount({
+      name,
+      description,
+      accountStatus,
+      scopes,
+      jwks,
+      state: this.state
+    });
+  }
 
+  /**
+   * Get service account
+   * @param {string} serviceAccountId service account id
+   * @returns {Promise<ServiceAccount>} a promise resolving to a service account object
+   */
+  async getServiceAccount(serviceAccountId) {
+    return getServiceAccount({
+      serviceAccountId,
+      state: this.state
+    });
+  }
+}
+const moType = 'svcacct';
 /**
  * Check if service accounts are available
  * @returns {Promise<boolean>} true if service accounts are available, false otherwise
  */
-export async function isServiceAccountsFeatureAvailable() {
+export async function isServiceAccountsFeatureAvailable({
+  state
+}) {
   debugMessage(`ServiceAccountOps.isServiceAccountsFeatureAvailable: start`);
-  // only perform check once
-  if (typeof _featureAvailable !== 'undefined') return _featureAvailable;
-  _featureAvailable = await hasFeature('service-accounts');
-  debugMessage(`ServiceAccountOps.isServiceAccountsFeatureAvailable: end, available=${_featureAvailable}`);
-  return _featureAvailable;
+  const featureAvailable = await hasFeature({
+    featureId: 'service-accounts',
+    state
+  });
+  debugMessage(`ServiceAccountOps.isServiceAccountsFeatureAvailable: end, available=${featureAvailable}`);
+  return featureAvailable;
 }
 
 /**
@@ -27,9 +73,17 @@ export async function isServiceAccountsFeatureAvailable() {
  * @param {'Active' | 'Inactive'} accountStatus Service account status
  * @param {string[]} scopes Scopes.
  * @param {JwksInterface} jwks Java Web Key Set
+ * @param {State} state library state
  * @returns {Promise<IdObjectSkeletonInterface>} A promise resolving to a service account object
  */
-export async function createServiceAccount(name, description, accountStatus, scopes, jwks) {
+export async function createServiceAccount({
+  name,
+  description,
+  accountStatus,
+  scopes,
+  jwks,
+  state
+}) {
   debugMessage(`ServiceAccountOps.createServiceAccount: start`);
   const payload = {
     name,
@@ -40,12 +94,28 @@ export async function createServiceAccount(name, description, accountStatus, sco
   };
   debugMessage(`ServiceAccountOps: createServiceAccount: payload:`);
   debugMessage(payload);
-  const result = await createManagedObject(moType, payload);
+  const result = await createManagedObject(getTenantURL(state.getHost()), moType, payload, state);
   debugMessage(`ServiceAccountOps.createServiceAccount: end`);
   return result;
 }
-export async function getServiceAccount(serviceAccountId) {
-  const serviceAccount = await getManagedObject(moType, serviceAccountId);
+
+/**
+ * Get service account
+ * @param {string} serviceAccountId service account id
+ * @param {State} state library state
+ * @returns {Promise} a promise resolving to a service account object
+ */
+export async function getServiceAccount({
+  serviceAccountId,
+  state
+}) {
+  const serviceAccount = await getManagedObject({
+    baseUrl: getTenantURL(state.getHost()),
+    type: moType,
+    id: serviceAccountId,
+    fields: ['*'],
+    state
+  });
   return serviceAccount;
 }
 //# sourceMappingURL=ServiceAccountOps.js.map

package/esm/ops/cloud/ServiceAccountOps.test.mjs

@@ -27,13 +27,14 @@
  *    If 1 and 2 didn't produce any errors, you are ready to run the tests in
  *    replay mode and make sure they all succeed as well:
  *
- *        npm run test:only ServiceAccountOps
+ *        FRODO_DEBUG=1 npm run test:only ServiceAccountOps
  *
  * Note: FRODO_DEBUG=1 is optional and enables debug logging for some output
  * in case things don't function as expected
  */
+import { state } from '../../index';
+import * as ServiceAccountOps from './ServiceAccountOps';
 import { createJwkRsa, createJwks, getJwkRsaPublic } from '../JoseOps';
-import * as ServiceAccount from './ServiceAccountOps';
 import { autoSetupPolly, defaultMatchRequestsBy } from '../../utils/AutoSetupPolly';
 
 // need to modify the default matching rules to allow the mocking to work for service account tests.
@@ -44,10 +45,12 @@ autoSetupPolly(matchConfig);
 describe.only('ServiceAccountOps', () => {
   describe('isServiceAccountsFeatureAvailable()', () => {
     test('0: Method is implemented', async () => {
-      expect(ServiceAccount.isServiceAccountsFeatureAvailable).toBeDefined();
+      expect(ServiceAccountOps.isServiceAccountsFeatureAvailable).toBeDefined();
     });
     test('1: Check tenant supporting service accounts', async () => {
-      const response = await ServiceAccount.isServiceAccountsFeatureAvailable();
+      const response = await ServiceAccountOps.isServiceAccountsFeatureAvailable({
+        state
+      });
       expect(response).toBeTruthy();
     });
 
@@ -65,7 +68,7 @@ describe.only('ServiceAccountOps', () => {
 
   describe('createServiceAccount()', () => {
     test('0: Method is implemented', async () => {
-      expect(ServiceAccount.createServiceAccount).toBeDefined();
+      expect(ServiceAccountOps.createServiceAccount).toBeDefined();
     });
     test('1: Create service account', async () => {
       const name = 'sa';
@@ -75,7 +78,14 @@ describe.only('ServiceAccountOps', () => {
       const jwk = await createJwkRsa();
       const publicJwk = await getJwkRsaPublic(jwk);
       const jwks = createJwks(publicJwk);
-      const response = await ServiceAccount.createServiceAccount(name, description, accountStatus, scopes, jwks);
+      const response = await ServiceAccountOps.createServiceAccount({
+        name,
+        description,
+        accountStatus,
+        scopes,
+        jwks,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });

package/esm/ops/cloud/StartupOps.mjs

@@ -2,6 +2,35 @@ import { createProgressIndicator, updateProgressIndicator, stopProgressIndicator
 import { getSecrets } from '../../api/cloud/SecretsApi';
 import { getStatus, initiateRestart, RestartStatus } from '../../api/cloud/StartupApi';
 import { getVariables } from '../../api/cloud/VariablesApi';
+export default class StartupOps {
+  constructor(state) {
+    this.state = state;
+  }
+
+  /**
+   * Check for updates that need applying
+   * @returns {Promise<Updates>} true if there are updates that need to be applied, false otherwise
+   */
+  async checkForUpdates() {
+    return checkForUpdates({
+      state: this.state
+    });
+  }
+
+  /**
+   * Apply updates
+   * @param {boolean} wait wait for the operation to complete or not
+   * @param {number} timeout timeout in milliseconds
+   * @returns {Promise<boolean>} true if successful, false otherwise
+   */
+  async applyUpdates(wait, timeout = 10 * 60 * 1000) {
+    return applyUpdates({
+      wait,
+      timeout,
+      state: this.state
+    });
+  }
+}
 
 /**
  * Updates that need to be applied.
@@ -11,7 +40,9 @@ import { getVariables } from '../../api/cloud/VariablesApi';
  * Check for updates that need applying
  * @returns {Promise<boolean>} true if there are updates that need to be applied, false otherwise
  */
-export async function checkForUpdates() {
+export async function checkForUpdates({
+  state
+}) {
   var _updates$secrets, _updates$variables;
   const updates = {
     secrets: [],
@@ -19,8 +50,12 @@ export async function checkForUpdates() {
   };
   createProgressIndicator(undefined, `Checking for updates to apply...`, 'indeterminate');
   try {
-    updates.secrets = (await getSecrets()).result.filter(secret => !secret.loaded);
-    updates.variables = (await getVariables()).result.filter(variable => !variable.loaded);
+    updates.secrets = (await getSecrets({
+      state
+    })).result.filter(secret => !secret.loaded);
+    updates.variables = (await getVariables({
+      state
+    })).result.filter(variable => !variable.loaded);
   } catch (error) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
@@ -39,10 +74,16 @@ export async function checkForUpdates() {
  * @param {number} timeout timeout in milliseconds
  * @returns {Promise<boolean>} true if successful, false otherwise
  */
-export async function applyUpdates(wait, timeout = 10 * 60 * 1000) {
+export async function applyUpdates({
+  wait,
+  timeout = 10 * 60 * 1000,
+  state
+}) {
   createProgressIndicator(undefined, `Applying updates...`, 'indeterminate');
   try {
-    let status = await initiateRestart();
+    let status = await initiateRestart({
+      state
+    });
     if (wait) {
       const start = new Date().getTime();
       let runtime = 0;
@@ -51,7 +92,9 @@ export async function applyUpdates(wait, timeout = 10 * 60 * 1000) {
       while (status !== RestartStatus.ready && start + timeout > new Date().getTime()) {
         await new Promise(resolve => setTimeout(resolve, 5000));
         try {
-          status = await getStatus();
+          status = await getStatus({
+            state
+          });
 
           // reset errors after successful status call
           if (errors) errors = 0;