@rockcarver/frodo-lib 1.0.0 → 2.0.0-2

package/esm/api/PolicySetApi.test.mjs

@@ -30,19 +30,29 @@
  * in case things don't function as expected
  */
 import * as PolicySetApi from './PolicySetApi';
+import { state } from '../index';
 import { autoSetupPolly } from '../utils/AutoSetupPolly';
 import { cloneDeep } from '../ops/utils/OpsUtils';
 autoSetupPolly();
 async function stagePolicySet(policySet, create = true) {
   // delete if exists, then create
   try {
-    await PolicySetApi.getPolicySet(policySet.name);
-    await PolicySetApi.deletePolicySet(policySet.name);
+    await PolicySetApi.getPolicySet({
+      policySetName: policySet.name,
+      state
+    });
+    await PolicySetApi.deletePolicySet({
+      policySetName: policySet.name,
+      state
+    });
   } catch (error) {
     // ignore
   } finally {
     if (create) {
-      await PolicySetApi.createPolicySet(policySet);
+      await PolicySetApi.createPolicySet({
+        policySetData: policySet,
+        state
+      });
     }
   }
 }
@@ -100,7 +110,9 @@ describe('PolicySetApi', () => {
       expect(PolicySetApi.getPolicySets).toBeDefined();
     });
     test('1: Get all policy sets', async () => {
-      const response = await PolicySetApi.getPolicySets();
+      const response = await PolicySetApi.getPolicySets({
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
@@ -109,13 +121,19 @@ describe('PolicySetApi', () => {
       expect(PolicySetApi.getPolicySet).toBeDefined();
     });
     test(`1: Get existing policy set [${set1.name}]`, async () => {
-      const response = await PolicySetApi.getPolicySet(set1.name);
+      const response = await PolicySetApi.getPolicySet({
+        policySetName: set1.name,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
     test('2: Get non-existing policy set by uuid [DoesNotExist]', async () => {
       expect.assertions(1);
       try {
-        await PolicySetApi.getPolicySet('DoesNotExist');
+        await PolicySetApi.getPolicySet({
+          policySetName: 'DoesNotExist',
+          state
+        });
       } catch (error) {
         expect(error.response.data).toMatchSnapshot();
       }
@@ -126,13 +144,19 @@ describe('PolicySetApi', () => {
       expect(PolicySetApi.createPolicySet).toBeDefined();
     });
     test(`1: Create non-existing policy set [${set2.name}]`, async () => {
-      const response = await PolicySetApi.createPolicySet(set2);
+      const response = await PolicySetApi.createPolicySet({
+        policySetData: set2,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
     test(`2: Create existing policy set [${set3.name}]`, async () => {
       expect.assertions(1);
       try {
-        await PolicySetApi.createPolicySet(set3);
+        await PolicySetApi.createPolicySet({
+          policySetData: set3,
+          state
+        });
       } catch (error) {
         expect(error.response.data).toMatchSnapshot();
       }
@@ -143,13 +167,19 @@ describe('PolicySetApi', () => {
       expect(PolicySetApi.updatePolicySet).toBeDefined();
     });
     test(`1: Update existing policy set [${set4.name}]`, async () => {
-      const response = await PolicySetApi.updatePolicySet(set4);
+      const response = await PolicySetApi.updatePolicySet({
+        policySetData: set4,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
     test(`2: Update non-existing policy set [${set5.name}]`, async () => {
       expect.assertions(1);
       try {
-        await PolicySetApi.updatePolicySet(set5);
+        await PolicySetApi.updatePolicySet({
+          policySetData: set5,
+          state
+        });
       } catch (error) {
         expect(error.response.data).toMatchSnapshot();
       }
@@ -160,13 +190,19 @@ describe('PolicySetApi', () => {
       expect(PolicySetApi.deletePolicySet).toBeDefined();
     });
     test(`1: Delete existing policy set [${set6.name}]`, async () => {
-      const node = await PolicySetApi.deletePolicySet(set6.name);
+      const node = await PolicySetApi.deletePolicySet({
+        policySetName: set6.name,
+        state
+      });
       expect(node).toMatchSnapshot();
     });
     test('2: Delete non-existing policy set [DoesNotExist]', async () => {
       expect.assertions(1);
       try {
-        await PolicySetApi.deletePolicySet('DoesNotExist');
+        await PolicySetApi.deletePolicySet({
+          policySetName: 'DoesNotExist',
+          state
+        });
       } catch (error) {
         expect(error.response.data).toMatchSnapshot();
       }

package/esm/api/RealmApi.mjs

@@ -1,14 +1,11 @@
 import util from 'util';
-import { getTenantURL, getCurrentRealmPath, getRealmName } from './utils/ApiUtils';
+import { getTenantURL, getRealmName } from './utils/ApiUtils';
 import { generateAmApi } from './BaseApi';
-import * as state from '../shared/State';
 const realmsListURLTemplate = '%s/json/global-config/realms/?_queryFilter=true';
 const realmURLTemplate = '%s/json/global-config/realms/%s';
 const apiVersion = 'protocol=2.0,resource=1.0';
 const getApiConfig = () => {
-  const configPath = getCurrentRealmPath();
   return {
-    path: `${configPath}/am/json/global-config/realms`,
     apiVersion
   };
 };
@@ -17,63 +14,107 @@ const getApiConfig = () => {
  * Get all realms
  * @returns {Promise} a promise that resolves to an object containing an array of realm objects
  */
-export async function getRealms() {
+export async function getRealms({
+  state
+}) {
   const urlString = util.format(realmsListURLTemplate, state.getHost());
-  return generateAmApi(getApiConfig()).get(urlString, {
+  const {
+    data
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).get(urlString, {
     withCredentials: true
   });
+  return data;
 }
 
 /**
  * Get realm by id
- * @param {String} id realm id
+ * @param {String} realmId realm id
  * @returns {Promise} a promise that resolves to an object containing a realm object
  */
-export async function getRealm(id) {
-  const urlString = util.format(realmURLTemplate, state.getHost(), id);
-  return generateAmApi(getApiConfig()).get(urlString, {
+export async function getRealm({
+  realmId,
+  state
+}) {
+  const urlString = util.format(realmURLTemplate, state.getHost(), realmId);
+  const {
+    data
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).get(urlString, {
     withCredentials: true
   });
+  return data;
 }
 
 /**
  * Get realm by name
- * @param {String} name realm name
+ * @param {String} realmName realm name
  * @returns {Promise} a promise that resolves to a realm object
  */
-export async function getRealmByName(name) {
-  return getRealms().then(realms => {
+export async function getRealmByName({
+  realmName,
+  state
+}) {
+  const {
+    data
+  } = await getRealms({
+    state
+  }).then(realms => {
     for (const realm of realms.data.result) {
-      if (getRealmName(name) === realm.name) {
+      if (getRealmName(realmName) === realm.name) {
         return realm;
       }
     }
-    throw new Error(`Realm ${name} not found!`);
+    throw new Error(`Realm ${realmName} not found!`);
   });
+  return data;
 }
 
 /**
  * Put realm
- * @param {String} id realm id
- * @param {Object} data realm config object
+ * @param {string} realmId realm id
+ * @param {object} realmData realm config object
  * @returns {Promise} a promise that resolves to an object containing a realm object
  */
-export async function putRealm(id, data) {
-  const urlString = util.format(realmURLTemplate, state.getHost(), id);
-  return generateAmApi(getApiConfig()).put(urlString, data, {
+export async function putRealm({
+  realmId,
+  realmData,
+  state
+}) {
+  const urlString = util.format(realmURLTemplate, state.getHost(), realmId);
+  const {
+    data
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).put(urlString, realmData, {
     withCredentials: true
   });
+  return data;
 }
 
 /**
  * Delete realm
- * @param {String} id realm id
+ * @param {String} realmId realm id
  * @returns {Promise} a promise that resolves to an object containing a realm object
  */
-export async function deleteRealm(id) {
-  const urlString = util.format(realmURLTemplate, getTenantURL(state.getHost()), id);
-  return generateAmApi(getApiConfig()).delete(urlString, {
+export async function deleteRealm({
+  realmId,
+  state
+}) {
+  const urlString = util.format(realmURLTemplate, getTenantURL(state.getHost()), realmId);
+  const {
+    data
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).delete(urlString, {
     withCredentials: true
   });
+  return data;
 }
 //# sourceMappingURL=RealmApi.js.map

package/esm/api/ResourceTypesApi.mjs

@@ -1,7 +1,6 @@
 import util from 'util';
 import { getCurrentRealmPath } from './utils/ApiUtils';
 import { generateAmApi } from './BaseApi';
-import * as state from '../shared/State';
 const queryAllResourceTypesURLTemplate = '%s/json%s/resourcetypes?_sortKeys=name&_queryFilter=name+eq+%22%5E(%3F!Delegation%20Service%24).*%22';
 const queryResourceTypeByNameURLTemplate = '%s/json%s/resourcetypes?_sortKeys=name&_queryFilter=name+eq+%22%s%22+AND+name+eq+%22%5E(%3F!Delegation%20Service%24).*%22';
 const resourceTypeURLTemplate = '%s/json%s/resourcetypes/%s';
@@ -17,11 +16,16 @@ const getApiConfig = () => {
  * Get all resource types
  * @returns {Promise} a promise that resolves to an object containing an array of resource type objects
  */
-export async function getResourceTypes() {
-  const urlString = util.format(queryAllResourceTypesURLTemplate, state.getHost(), getCurrentRealmPath());
+export async function getResourceTypes({
+  state
+}) {
+  const urlString = util.format(queryAllResourceTypesURLTemplate, state.getHost(), getCurrentRealmPath(state));
   const {
     data
-  } = await generateAmApi(getApiConfig()).get(urlString, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).get(urlString, {
     withCredentials: true
   });
   return data;
@@ -32,11 +36,17 @@ export async function getResourceTypes() {
  * @param {String} resourceTypeUuid resource type uuid
  * @returns {Promise} a promise that resolves to a node object
  */
-export async function getResourceType(resourceTypeUuid) {
-  const urlString = util.format(resourceTypeURLTemplate, state.getHost(), getCurrentRealmPath(), resourceTypeUuid);
+export async function getResourceType({
+  resourceTypeUuid,
+  state
+}) {
+  const urlString = util.format(resourceTypeURLTemplate, state.getHost(), getCurrentRealmPath(state), resourceTypeUuid);
   const {
     data
-  } = await generateAmApi(getApiConfig()).get(urlString, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).get(urlString, {
     withCredentials: true
   });
   return data;
@@ -47,11 +57,17 @@ export async function getResourceType(resourceTypeUuid) {
  * @param {string} resourceTypeName resource type name
  * @returns {Promise} a promise that resolves to a node object
  */
-export async function getResourceTypeByName(resourceTypeName) {
-  const urlString = util.format(queryResourceTypeByNameURLTemplate, state.getHost(), getCurrentRealmPath(), resourceTypeName);
+export async function getResourceTypeByName({
+  resourceTypeName,
+  state
+}) {
+  const urlString = util.format(queryResourceTypeByNameURLTemplate, state.getHost(), getCurrentRealmPath(state), resourceTypeName);
   const {
     data
-  } = await generateAmApi(getApiConfig()).get(urlString, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).get(urlString, {
     withCredentials: true
   });
   return data;
@@ -63,11 +79,17 @@ export async function getResourceTypeByName(resourceTypeName) {
  * @param {Object} resourceTypeData resource type object
  * @returns {Promise<ResourceTypeSkeleton>} a promise that resolves to a resource type object
  */
-export async function createResourceType(resourceTypeData) {
-  const urlString = util.format(createResourceTypeURLTemplate, state.getHost(), getCurrentRealmPath());
+export async function createResourceType({
+  resourceTypeData,
+  state
+}) {
+  const urlString = util.format(createResourceTypeURLTemplate, state.getHost(), getCurrentRealmPath(state));
   const {
     data
-  } = await generateAmApi(getApiConfig()).post(urlString, resourceTypeData, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).post(urlString, resourceTypeData, {
     withCredentials: true
   });
   return data;
@@ -75,15 +97,22 @@ export async function createResourceType(resourceTypeData) {
 
 /**
  * Update resource type by uuid
- * @param {String} resourceTypeUuid resource type uuid
- * @param {Object} resourceTypeData resource type object
+ * @param {string} resourceTypeUuid resource type uuid
+ * @param {ResourceTypeSkeleton} resourceTypeData resource type object
  * @returns {Promise} a promise that resolves to a resource type object
  */
-export async function putResourceType(resourceTypeUuid, resourceTypeData) {
-  const urlString = util.format(resourceTypeURLTemplate, state.getHost(), getCurrentRealmPath(), resourceTypeUuid);
+export async function putResourceType({
+  resourceTypeUuid,
+  resourceTypeData,
+  state
+}) {
+  const urlString = util.format(resourceTypeURLTemplate, state.getHost(), getCurrentRealmPath(state), resourceTypeUuid);
   const {
     data
-  } = await generateAmApi(getApiConfig()).put(urlString, resourceTypeData, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).put(urlString, resourceTypeData, {
     withCredentials: true
   });
   return data;
@@ -94,11 +123,17 @@ export async function putResourceType(resourceTypeUuid, resourceTypeData) {
  * @param {String} resourceTypeUuid resource type uuid
  * @returns {Promise} a promise that resolves to an object containing a resource type object
  */
-export async function deleteResourceType(resourceTypeUuid) {
-  const urlString = util.format(resourceTypeURLTemplate, state.getHost(), getCurrentRealmPath(), resourceTypeUuid);
+export async function deleteResourceType({
+  resourceTypeUuid,
+  state
+}) {
+  const urlString = util.format(resourceTypeURLTemplate, state.getHost(), getCurrentRealmPath(state), resourceTypeUuid);
   const {
     data
-  } = await generateAmApi(getApiConfig()).delete(urlString, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).delete(urlString, {
     withCredentials: true
   });
   return data;

package/esm/api/ResourceTypesApi.test.mjs

@@ -30,18 +30,28 @@
  * in case things don't function as expected
  */
 import * as ResourceTypesApi from './ResourceTypesApi';
+import { state } from '../index';
 import { autoSetupPolly } from '../utils/AutoSetupPolly';
 autoSetupPolly();
 async function stageResourceType(type, create = true) {
   // delete if exists, then create
   try {
-    await ResourceTypesApi.getResourceType(type.uuid);
-    await ResourceTypesApi.deleteResourceType(type.uuid);
+    await ResourceTypesApi.getResourceType({
+      resourceTypeUuid: type.uuid,
+      state
+    });
+    await ResourceTypesApi.deleteResourceType({
+      resourceTypeUuid: type.uuid,
+      state
+    });
   } catch (error) {
     // ignore
   } finally {
     if (create) {
-      await ResourceTypesApi.createResourceType(type);
+      await ResourceTypesApi.createResourceType({
+        resourceTypeData: type,
+        state
+      });
     }
   }
 }
@@ -145,7 +155,9 @@ describe('ResourceTypesApi', () => {
       expect(ResourceTypesApi.getResourceTypes).toBeDefined();
     });
     test('1: Get all resource types', async () => {
-      const response = await ResourceTypesApi.getResourceTypes();
+      const response = await ResourceTypesApi.getResourceTypes({
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
@@ -154,13 +166,19 @@ describe('ResourceTypesApi', () => {
       expect(ResourceTypesApi.getResourceType).toBeDefined();
     });
     test(`1: Get existing resource type by uuid [${type1.uuid} - ${type1.name}]`, async () => {
-      const response = await ResourceTypesApi.getResourceType(type1.uuid);
+      const response = await ResourceTypesApi.getResourceType({
+        resourceTypeUuid: type1.uuid,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
     test('2: Get non-existing resource type by uuid [00000000-0000-0000-0000-000000000000]', async () => {
       expect.assertions(1);
       try {
-        await ResourceTypesApi.getResourceType('00000000-0000-0000-0000-000000000000');
+        await ResourceTypesApi.getResourceType({
+          resourceTypeUuid: '00000000-0000-0000-0000-000000000000',
+          state
+        });
       } catch (error) {
         expect(error.response.data).toMatchSnapshot();
       }
@@ -171,11 +189,17 @@ describe('ResourceTypesApi', () => {
       expect(ResourceTypesApi.getResourceTypeByName).toBeDefined();
     });
     test(`1: Get existing resource type by name [${type2.name} - ${type2.uuid}]`, async () => {
-      const response = await ResourceTypesApi.getResourceTypeByName(type2.name);
+      const response = await ResourceTypesApi.getResourceTypeByName({
+        resourceTypeName: type2.name,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
     test('2: Get non-existing resource type by name [DoesNotExist]', async () => {
-      const response = await ResourceTypesApi.getResourceTypeByName('DoesNotExist');
+      const response = await ResourceTypesApi.getResourceTypeByName({
+        resourceTypeName: 'DoesNotExist',
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
@@ -184,13 +208,19 @@ describe('ResourceTypesApi', () => {
       expect(ResourceTypesApi.createResourceType).toBeDefined();
     });
     test(`1: Create non-existing resource type [${type3.uuid} - ${type3.name}]`, async () => {
-      const response = await ResourceTypesApi.createResourceType(type3);
+      const response = await ResourceTypesApi.createResourceType({
+        resourceTypeData: type3,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
     test(`2: Create existing resource type [${type4.uuid} - ${type4.name}]`, async () => {
       expect.assertions(1);
       try {
-        await ResourceTypesApi.createResourceType(type4);
+        await ResourceTypesApi.createResourceType({
+          resourceTypeData: type4,
+          state
+        });
       } catch (error) {
         expect(error.response.data).toMatchSnapshot();
       }
@@ -201,13 +231,21 @@ describe('ResourceTypesApi', () => {
       expect(ResourceTypesApi.putResourceType).toBeDefined();
     });
     test(`1: Update existing resource type [${type5.uuid} - ${type5.name}]`, async () => {
-      const response = await ResourceTypesApi.putResourceType(type5.uuid, type5);
+      const response = await ResourceTypesApi.putResourceType({
+        resourceTypeUuid: type5.uuid,
+        resourceTypeData: type5,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
     test(`2: Update non-existing resource type [${type6.uuid} - ${type6.name}]`, async () => {
       expect.assertions(1);
       try {
-        await ResourceTypesApi.putResourceType(type6.uuid, type6);
+        await ResourceTypesApi.putResourceType({
+          resourceTypeUuid: type6.uuid,
+          resourceTypeData: type6,
+          state
+        });
       } catch (error) {
         expect(error.response.data).toMatchSnapshot();
       }
@@ -218,13 +256,19 @@ describe('ResourceTypesApi', () => {
       expect(ResourceTypesApi.deleteResourceType).toBeDefined();
     });
     test(`1: Delete existing resource type [${type7.uuid} - ${type7.name}]`, async () => {
-      const node = await ResourceTypesApi.deleteResourceType(type7.uuid);
+      const node = await ResourceTypesApi.deleteResourceType({
+        resourceTypeUuid: type7.uuid,
+        state
+      });
       expect(node).toMatchSnapshot();
     });
     test('2: Delete non-existing resource type [00000000-0000-0000-0000-000000000000]', async () => {
       expect.assertions(1);
       try {
-        await ResourceTypesApi.deleteResourceType('00000000-0000-0000-0000-000000000000');
+        await ResourceTypesApi.deleteResourceType({
+          resourceTypeUuid: '00000000-0000-0000-0000-000000000000',
+          state
+        });
       } catch (error) {
         expect(error.response.data).toMatchSnapshot();
       }