@rockcarver/frodo-lib 1.0.0 → 2.0.0-1

package/esm/ops/IdmOps.mjs

@@ -1,59 +1,72 @@
-import { getAllConfigEntities as _getAllConfigEntities, getConfigEntity as _getConfigEntity, putConfigEntity as _putConfigEntity, getConfigEntitiesByType as _getConfigEntitiesByType, queryAllManagedObjectsByType as _queryAllManagedObjectsByType } from '../api/IdmConfigApi';
+import { getAllConfigEntities, getConfigEntity, putConfigEntity, getConfigEntitiesByType, queryAllManagedObjectsByType } from '../api/IdmConfigApi';
 import { testConnectorServers as _testConnectorServers } from '../api/IdmSystemApi';
+export default class IdmOps {
+  constructor(state) {
+    this.state = state;
+  }
+  getAllConfigEntities() {
+    return getAllConfigEntities({
+      state: this.state
+    });
+  }
+  getConfigEntitiesByType(type) {
+    return getConfigEntitiesByType({
+      type,
+      state: this.state
+    });
+  }
+  getConfigEntity(entityId) {
+    return getConfigEntity({
+      entityId,
+      state: this.state
+    });
+  }
+  putConfigEntity(entityId, entityData) {
+    return putConfigEntity({
+      entityId,
+      entityData,
+      state: this.state
+    });
+  }
 
-/**
- * Get all IDM config entities
- * @returns {Promise} a promise that resolves to all IDM config entities
- */
-export async function getAllConfigEntities() {
-  return _getAllConfigEntities();
-}
+  /**
+   * Query managed objects
+   * @param {string} type managed object type
+   * @param {string[]} fields fields to retrieve
+   * @param {string} pageCookie paged results cookie
+   * @returns {Promise<PagedResult<IdObjectSkeletonInterface>>} a promise that resolves to managed objects of the desired type
+   */
+  queryAllManagedObjectsByType(type, fields, pageCookie) {
+    return queryAllManagedObjectsByType({
+      type,
+      fields,
+      pageCookie,
+      state: this.state
+    });
+  }
 
-/**
- * Get IDM config entities by type
- * @param {String} type the desired type of config entity
- * @returns {Promise} a promise that resolves to an object containing all IDM config entities of the desired type
- */
-export async function getConfigEntitiesByType(type) {
-  return _getConfigEntitiesByType(type);
-}
-
-/**
- * Get an IDM config entity
- * @param {string} entityId the desired config entity
- * @returns {Promise<unknown>} a promise that resolves to an IDM config entity
- */
-export async function getConfigEntity(entityId) {
-  return _getConfigEntity(entityId);
-}
-
-/**
- * Put IDM config entity
- * @param {string} entityId config entity id
- * @param {string} entityData config entity object
- * @returns {Promise<unknown>} a promise that resolves to an IDM config entity
- */
-export async function putConfigEntity(entityId, entityData) {
-  return _putConfigEntity(entityId, entityData);
-}
-
-/**
- * Query managed objects
- * @param {string} type managed object type
- * @param {string[]} fields fields to retrieve
- * @param {string} pageCookie paged results cookie
- * @returns {Promise<{result: any[]; resultCount: number; pagedResultsCookie: any; totalPagedResultsPolicy: string; totalPagedResults: number; remainingPagedResults: number;}>} a promise that resolves to managed objects of the desired type
- */
-export async function queryAllManagedObjectsByType(type, fields = [], pageCookie = undefined) {
-  return _queryAllManagedObjectsByType(type, fields, pageCookie);
+  /**
+   * Test connector servers
+   * @returns {Promise<ConnectorServerStatusInterface[]>} a promise that resolves to an array of ConnectorServerStatusInterface objects
+   */
+  async testConnectorServers() {
+    return testConnectorServers({
+      state: this.state
+    });
+  }
 }
+export { getAllConfigEntities, getConfigEntitiesByType, getConfigEntity, putConfigEntity, queryAllManagedObjectsByType };
 
 /**
  * Test connector servers
  * @returns {Promise<ConnectorServerStatusInterface[]>} a promise that resolves to an array of ConnectorServerStatusInterface objects
  */
-export async function testConnectorServers() {
-  const response = await _testConnectorServers();
+export async function testConnectorServers({
+  state
+}) {
+  const response = await _testConnectorServers({
+    state
+  });
   return response.openicf;
 }
 //# sourceMappingURL=IdmOps.js.map

package/esm/ops/IdmOps.test.mjs

@@ -29,19 +29,31 @@
  * Note: FRODO_DEBUG=1 is optional and enables debug logging for some output
  * in case things don't function as expected
  */
-import { Idm, IdmConfigRaw } from '../index';
+import { state } from '../index';
+import * as IdmConfigApi from '../api/IdmConfigApi';
+import * as IdmOps from './IdmOps';
 import { autoSetupPolly } from '../utils/AutoSetupPolly';
 autoSetupPolly();
 async function stageConfigEntity(configEntity, create = true) {
   // delete if exists, then create
   try {
-    await IdmConfigRaw.getConfigEntity(configEntity.id);
-    await IdmConfigRaw.deleteConfigEntity(configEntity.id);
+    await IdmConfigApi.getConfigEntity({
+      entityId: configEntity.id,
+      state
+    });
+    await IdmConfigApi.deleteConfigEntity({
+      entityId: configEntity.id,
+      state
+    });
   } catch (error) {
     // ignore
   } finally {
     if (create) {
-      await IdmConfigRaw.putConfigEntity(configEntity.id, configEntity.data);
+      await IdmConfigApi.putConfigEntity({
+        entityId: configEntity.id,
+        entityData: configEntity.data,
+        state
+      });
     }
   }
 }
@@ -114,63 +126,87 @@ describe('IdmOps', () => {
   });
   describe('getAllConfigEntities()', () => {
     test('0: Method is implemented', async () => {
-      expect(Idm.getAllConfigEntities).toBeDefined();
+      expect(IdmOps.getAllConfigEntities).toBeDefined();
     });
     test('1: get all config entities', async () => {
-      const response = await Idm.getAllConfigEntities();
+      const response = await IdmOps.getAllConfigEntities({
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
   describe('getConfigEntitiesByType()', () => {
     test('0: Method is implemented', async () => {
-      expect(Idm.getConfigEntitiesByType).toBeDefined();
+      expect(IdmOps.getConfigEntitiesByType).toBeDefined();
     });
     test('1: Get config entity by type (emailTemplate)', async () => {
-      const response = await Idm.getConfigEntitiesByType('emailTemplate');
+      const response = await IdmOps.getConfigEntitiesByType({
+        type: 'emailTemplate',
+        state
+      });
       expect(response).toMatchSnapshot();
     });
     test('2: Get config entity by type (managed)', async () => {
-      const response = await Idm.getConfigEntitiesByType('managed');
+      const response = await IdmOps.getConfigEntitiesByType({
+        type: 'managed',
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
   describe('getConfigEntity()', () => {
     test('0: Method is implemented', async () => {
-      expect(Idm.getConfigEntity).toBeDefined();
+      expect(IdmOps.getConfigEntity).toBeDefined();
     });
     test(`1: Get config entity '${configEntity1.id}'`, async () => {
-      const response = await Idm.getConfigEntity(configEntity1.id);
+      const response = await IdmOps.getConfigEntity({
+        entityId: configEntity1.id,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
     test("2: Get config entity 'managed'", async () => {
-      const response = await Idm.getConfigEntity('managed');
+      const response = await IdmOps.getConfigEntity({
+        entityId: 'managed',
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
   describe('putConfigEntity()', () => {
     test('0: Method is implemented', async () => {
-      expect(Idm.putConfigEntity).toBeDefined();
+      expect(IdmOps.putConfigEntity).toBeDefined();
     });
     test(`1: Put a config entity '${configEntity3.id}'`, async () => {
-      const response = await Idm.putConfigEntity(configEntity3.id, configEntity3.data);
+      const response = await IdmOps.putConfigEntity({
+        entityId: configEntity3.id,
+        entityData: configEntity3.data,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
   describe('queryAllManagedObjectsByType()', () => {
     test('0: Method is implemented', async () => {
-      expect(Idm.queryAllManagedObjectsByType).toBeDefined();
+      expect(IdmOps.queryAllManagedObjectsByType).toBeDefined();
     });
     test(`1: Query managed objects of type 'alpha_user'`, async () => {
-      const response = await Idm.queryAllManagedObjectsByType('alpha_user', ['*']);
+      const response = await IdmOps.queryAllManagedObjectsByType({
+        type: 'alpha_user',
+        fields: ['*'],
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
   describe('testConnectorServers()', () => {
     test('0: Method is implemented', async () => {
-      expect(Idm.testConnectorServers).toBeDefined();
+      expect(IdmOps.testConnectorServers).toBeDefined();
     });
     test(`1: Test connector servers`, async () => {
-      const response = await Idm.testConnectorServers();
+      const response = await IdmOps.testConnectorServers({
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });

package/esm/ops/IdpOps.mjs

@@ -4,15 +4,122 @@ import { putScript } from './ScriptOps';
 import { convertBase64TextToArray, convertTextArrayToBase64 } from './utils/ExportImportUtils';
 import { printMessage, createProgressIndicator, updateProgressIndicator, stopProgressIndicator } from './utils/Console';
 import { getMetadata } from './utils/ExportImportUtils';
-import * as state from '../shared/State';
 import { debugMessage } from './utils/Console';
+export default class IdpOps {
+  constructor(state) {
+    this.state = state;
+  }
+
+  /**
+   * Get all social identity providers
+   * @returns {Promise} a promise that resolves to an object containing an array of social identity providers
+   */
+  async getSocialIdentityProviders() {
+    return getSocialIdentityProviders({
+      state: this.state
+    });
+  }
+
+  /**
+   * Get social identity provider by id
+   * @param {String} providerId social identity provider id/name
+   * @returns {Promise} a promise that resolves a social identity provider object
+   */
+  async getSocialProvider(providerId) {
+    return getSocialProvider({
+      providerId,
+      state: this.state
+    });
+  }
+  async putProviderByTypeAndId(providerType, providerId, providerData) {
+    return putProviderByTypeAndId({
+      providerType,
+      providerId,
+      providerData,
+      state: this.state
+    });
+  }
+
+  /**
+   * Delete social identity provider by id
+   * @param {String} providerId social identity provider id/name
+   * @returns {Promise} a promise that resolves a social identity provider object
+   */
+  async deleteSocialProvider(providerId) {
+    return deleteSocialProvider({
+      providerId,
+      state: this.state
+    });
+  }
+
+  /**
+   * Export social provider by id
+   * @param {string} providerId provider id/name
+   * @returns {Promise<SocialProviderExportInterface>} a promise that resolves to a SocialProviderExportInterface object
+   */
+  async exportSocialProvider(providerId) {
+    return exportSocialProvider({
+      providerId,
+      state: this.state
+    });
+  }
+
+  /**
+   * Export all providers
+   * @returns {Promise<SocialProviderExportInterface>} a promise that resolves to a SocialProviderExportInterface object
+   */
+  async exportSocialProviders() {
+    return exportSocialProviders({
+      state: this.state
+    });
+  }
+
+  /**
+   * Import provider by id/name
+   * @param {string} providerId provider id/name
+   * @param {SocialProviderExportInterface} importData import data
+   */
+  async importSocialProvider(providerId, importData) {
+    return importSocialProvider({
+      providerId,
+      importData,
+      state: this.state
+    });
+  }
+
+  /**
+   * Import first provider
+   * @param {SocialProviderExportInterface} importData import data
+   */
+  async importFirstSocialProvider(importData) {
+    return importFirstSocialProvider({
+      importData,
+      state: this.state
+    });
+  }
+
+  /**
+   * Import all providers
+   * @param {SocialProviderExportInterface} importData import data
+   */
+  async importSocialProviders(importData) {
+    return importSocialProviders({
+      importData,
+      state: this.state
+    });
+  }
+}
 /**
  * Create an empty idp export template
  * @returns {SocialProviderExportInterface} an empty idp export template
  */
-function createIdpExportTemplate() {
+function createIdpExportTemplate({
+  state
+}) {
   return {
-    meta: getMetadata(),
+    meta: getMetadata({
+      state
+    }),
     script: {},
     idp: {}
   };
@@ -22,10 +129,14 @@ function createIdpExportTemplate() {
  * Get all social identity providers
  * @returns {Promise} a promise that resolves to an object containing an array of social identity providers
  */
-export async function getSocialIdentityProviders() {
+export async function getSocialIdentityProviders({
+  state
+}) {
   const {
     result
-  } = await _getSocialIdentityProviders();
+  } = await _getSocialIdentityProviders({
+    state
+  });
   return result;
 }
 
@@ -34,8 +145,13 @@ export async function getSocialIdentityProviders() {
  * @param {String} providerId social identity provider id/name
  * @returns {Promise} a promise that resolves a social identity provider object
  */
-export async function getSocialProvider(providerId) {
-  const response = await getSocialIdentityProviders();
+export async function getSocialProvider({
+  providerId,
+  state
+}) {
+  const response = await getSocialIdentityProviders({
+    state
+  });
   const foundProviders = response.filter(provider => provider._id === providerId);
   switch (foundProviders.length) {
     case 1:
@@ -46,10 +162,20 @@ export async function getSocialProvider(providerId) {
       throw new Error(`${foundProviders.length} providers '${providerId}' found`);
   }
 }
-export async function putProviderByTypeAndId(providerType, providerId, providerData) {
+export async function putProviderByTypeAndId({
+  providerType,
+  providerId,
+  providerData,
+  state
+}) {
   debugMessage(`IdpOps.putProviderByTypeAndId: start`);
   try {
-    const response = await _putProviderByTypeAndId(providerType, providerId, providerData);
+    const response = await _putProviderByTypeAndId({
+      type: providerType,
+      id: providerId,
+      providerData,
+      state
+    });
     debugMessage(`IdpOps.putProviderByTypeAndId: end`);
     return response;
   } catch (importError) {
@@ -66,7 +192,12 @@ export async function putProviderByTypeAndId(providerType, providerId, providerD
         }
       }
       if (state.getVerbose()) printMessage('\n', 'warn', false);
-      const response = await _putProviderByTypeAndId(providerType, providerId, providerData);
+      const response = await _putProviderByTypeAndId({
+        type: providerType,
+        id: providerId,
+        providerData,
+        state
+      });
       debugMessage(`IdpOps.putProviderByTypeAndId: end (after retry)`);
       return response;
     } else {
@@ -81,12 +212,21 @@ export async function putProviderByTypeAndId(providerType, providerId, providerD
  * @param {String} providerId social identity provider id/name
  * @returns {Promise} a promise that resolves a social identity provider object
  */
-export async function deleteSocialProvider(providerId) {
-  const response = await getSocialIdentityProviders();
+export async function deleteSocialProvider({
+  providerId,
+  state
+}) {
+  const response = await getSocialIdentityProviders({
+    state
+  });
   const foundProviders = response.filter(provider => provider._id === providerId);
   switch (foundProviders.length) {
     case 1:
-      return await deleteProviderByTypeAndId(foundProviders[0]._type._id, foundProviders[0]._id);
+      return await deleteProviderByTypeAndId({
+        type: foundProviders[0]._type._id,
+        providerId: foundProviders[0]._id,
+        state
+      });
     case 0:
       throw new Error(`Provider '${providerId}' not found`);
     default:
@@ -99,13 +239,24 @@ export async function deleteSocialProvider(providerId) {
  * @param {string} providerId provider id/name
  * @returns {Promise<SocialProviderExportInterface>} a promise that resolves to a SocialProviderExportInterface object
  */
-export async function exportSocialProvider(providerId) {
+export async function exportSocialProvider({
+  providerId,
+  state
+}) {
   debugMessage(`IdpOps.exportSocialProvider: start`);
-  const idpData = await getSocialProvider(providerId);
-  const exportData = createIdpExportTemplate();
+  const idpData = await getSocialProvider({
+    providerId,
+    state
+  });
+  const exportData = createIdpExportTemplate({
+    state
+  });
   exportData.idp[idpData._id] = idpData;
   if (idpData.transform) {
-    const scriptData = await getScript(idpData.transform);
+    const scriptData = await getScript({
+      scriptId: idpData.transform,
+      state
+    });
     scriptData.script = convertBase64TextToArray(scriptData.script);
     exportData.script[idpData.transform] = scriptData;
   }
@@ -117,16 +268,24 @@ export async function exportSocialProvider(providerId) {
  * Export all providers
  * @returns {Promise<SocialProviderExportInterface>} a promise that resolves to a SocialProviderExportInterface object
  */
-export async function exportSocialProviders() {
-  const exportData = createIdpExportTemplate();
-  const allIdpsData = await getSocialIdentityProviders();
+export async function exportSocialProviders({
+  state
+}) {
+  const exportData = createIdpExportTemplate({
+    state
+  });
+  const allIdpsData = await getSocialIdentityProviders({
+    state
+  });
   createProgressIndicator(allIdpsData.length, 'Exporting providers');
   for (const idpData of allIdpsData) {
     updateProgressIndicator(`Exporting provider ${idpData._id}`);
     exportData.idp[idpData._id] = idpData;
     if (idpData.transform) {
-      // eslint-disable-next-line no-await-in-loop
-      const scriptData = await getScript(idpData.transform);
+      const scriptData = await getScript({
+        scriptId: idpData.transform,
+        state
+      });
       scriptData.script = convertBase64TextToArray(scriptData.script);
       exportData.script[idpData.transform] = scriptData;
     }
@@ -140,16 +299,29 @@ export async function exportSocialProviders() {
  * @param {string} providerId provider id/name
  * @param {SocialProviderExportInterface} importData import data
  */
-export async function importSocialProvider(providerId, importData) {
+export async function importSocialProvider({
+  providerId,
+  importData,
+  state
+}) {
   for (const idpId of Object.keys(importData.idp)) {
     if (idpId === providerId) {
       const scriptId = importData.idp[idpId].transform;
       const scriptData = importData.script[scriptId];
       if (scriptId && scriptData) {
         scriptData.script = convertTextArrayToBase64(scriptData.script);
-        await putScript(scriptId, scriptData);
+        await putScript({
+          scriptId,
+          scriptData,
+          state
+        });
       }
-      await putProviderByTypeAndId(importData.idp[idpId]._type._id, idpId, importData.idp[idpId]);
+      await putProviderByTypeAndId({
+        providerType: importData.idp[idpId]._type._id,
+        providerId: idpId,
+        providerData: importData.idp[idpId],
+        state
+      });
       return true;
     }
   }
@@ -160,15 +332,27 @@ export async function importSocialProvider(providerId, importData) {
  * Import first provider
  * @param {SocialProviderExportInterface} importData import data
  */
-export async function importFirstSocialProvider(importData) {
+export async function importFirstSocialProvider({
+  importData,
+  state
+}) {
   for (const idpId of Object.keys(importData.idp)) {
     const scriptId = importData.idp[idpId].transform;
     const scriptData = importData.script[scriptId];
     if (scriptId && scriptData) {
       scriptData.script = convertTextArrayToBase64(scriptData.script);
-      await putScript(scriptId, scriptData);
+      await putScript({
+        scriptId,
+        scriptData,
+        state
+      });
     }
-    await putProviderByTypeAndId(importData.idp[idpId]._type._id, idpId, importData.idp[idpId]);
+    await putProviderByTypeAndId({
+      providerType: importData.idp[idpId]._type._id,
+      providerId: idpId,
+      providerData: importData.idp[idpId],
+      state
+    });
     return true;
   }
   return false;
@@ -178,7 +362,10 @@ export async function importFirstSocialProvider(importData) {
  * Import all providers
  * @param {SocialProviderExportInterface} importData import data
  */
-export async function importSocialProviders(importData) {
+export async function importSocialProviders({
+  importData,
+  state
+}) {
   let outcome = true;
   for (const idpId of Object.keys(importData.idp)) {
     try {
@@ -188,9 +375,18 @@ export async function importSocialProviders(importData) {
       };
       if (scriptId && scriptData) {
         scriptData.script = convertTextArrayToBase64(scriptData.script);
-        await putScript(scriptId, scriptData);
+        await putScript({
+          scriptId,
+          scriptData,
+          state
+        });
       }
-      await putProviderByTypeAndId(importData.idp[idpId]._type._id, idpId, importData.idp[idpId]);
+      await putProviderByTypeAndId({
+        providerType: importData.idp[idpId]._type._id,
+        providerId: idpId,
+        providerData: importData.idp[idpId],
+        state
+      });
     } catch (error) {
       var _error$response;
       printMessage(((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.data) || error, 'error');