@rockcarver/frodo-lib 1.0.0 → 2.0.0-2

package/esm/api/NodeApi.mjs

@@ -1,16 +1,13 @@
 import util from 'util';
 import { deleteDeepByKey, getCurrentRealmPath } from './utils/ApiUtils';
 import { generateAmApi } from './BaseApi';
-import * as state from '../shared/State';
 const queryAllNodeTypesURLTemplate = '%s/json%s/realm-config/authentication/authenticationtrees/nodes?_action=getAllTypes';
 const queryAllNodesByTypeURLTemplate = '%s/json%s/realm-config/authentication/authenticationtrees/nodes/%s?_queryFilter=true';
 const queryAllNodesURLTemplate = '%s/json%s/realm-config/authentication/authenticationtrees/nodes?_action=nextdescendents';
 const nodeURLTemplate = '%s/json%s/realm-config/authentication/authenticationtrees/nodes/%s/%s';
 const apiVersion = 'protocol=2.1,resource=1.0';
 const getNodeApiConfig = () => {
-  const configPath = getCurrentRealmPath();
   return {
-    path: `${configPath}/authentication/authenticationtrees`,
     apiVersion
   };
 };
@@ -19,11 +16,16 @@ const getNodeApiConfig = () => {
  * Get all node types
  * @returns {Promise} a promise that resolves to an array of node type objects
  */
-export async function getNodeTypes() {
-  const urlString = util.format(queryAllNodeTypesURLTemplate, state.getHost(), getCurrentRealmPath());
+export async function getNodeTypes({
+  state
+}) {
+  const urlString = util.format(queryAllNodeTypesURLTemplate, state.getHost(), getCurrentRealmPath(state));
   const {
     data
-  } = await generateAmApi(getNodeApiConfig()).post(urlString, {}, {
+  } = await generateAmApi({
+    resource: getNodeApiConfig(),
+    state
+  }).post(urlString, {}, {
     withCredentials: true,
     headers: {
       'Accept-Encoding': 'gzip, deflate, br'
@@ -36,11 +38,16 @@ export async function getNodeTypes() {
  * Get all nodes
  * @returns {Promise} a promise that resolves to an object containing an array of node objects
  */
-export async function getNodes() {
-  const urlString = util.format(queryAllNodesURLTemplate, state.getHost(), getCurrentRealmPath());
+export async function getNodes({
+  state
+}) {
+  const urlString = util.format(queryAllNodesURLTemplate, state.getHost(), getCurrentRealmPath(state));
   const {
     data
-  } = await generateAmApi(getNodeApiConfig()).post(urlString, {}, {
+  } = await generateAmApi({
+    resource: getNodeApiConfig(),
+    state
+  }).post(urlString, {}, {
     withCredentials: true,
     headers: {
       'Accept-Encoding': 'gzip, deflate, br'
@@ -54,11 +61,17 @@ export async function getNodes() {
  * @param {string} nodeType node type
  * @returns {Promise} a promise that resolves to an object containing an array of node objects of the requested type
  */
-export async function getNodesByType(nodeType) {
-  const urlString = util.format(queryAllNodesByTypeURLTemplate, state.getHost(), getCurrentRealmPath(), nodeType);
+export async function getNodesByType({
+  nodeType,
+  state
+}) {
+  const urlString = util.format(queryAllNodesByTypeURLTemplate, state.getHost(), getCurrentRealmPath(state), nodeType);
   const {
     data
-  } = await generateAmApi(getNodeApiConfig()).get(urlString, {
+  } = await generateAmApi({
+    resource: getNodeApiConfig(),
+    state
+  }).get(urlString, {
     withCredentials: true
   });
   return data;
@@ -70,11 +83,18 @@ export async function getNodesByType(nodeType) {
  * @param {String} nodeType node type
  * @returns {Promise} a promise that resolves to a node object
  */
-export async function getNode(nodeId, nodeType) {
-  const urlString = util.format(nodeURLTemplate, state.getHost(), getCurrentRealmPath(), nodeType, nodeId);
+export async function getNode({
+  nodeId,
+  nodeType,
+  state
+}) {
+  const urlString = util.format(nodeURLTemplate, state.getHost(), getCurrentRealmPath(state), nodeType, nodeId);
   const {
     data
-  } = await generateAmApi(getNodeApiConfig()).get(urlString, {
+  } = await generateAmApi({
+    resource: getNodeApiConfig(),
+    state
+  }).get(urlString, {
     withCredentials: true
   });
   return data;
@@ -82,19 +102,27 @@ export async function getNode(nodeId, nodeType) {
 
 /**
  * Put node by uuid and type
- * @param {String} nodeId node uuid
- * @param {String} nodeType node type
- * @param {Object} nodeData node object
+ * @param {string} nodeId node uuid
+ * @param {string} nodeType node type
+ * @param {object} nodeData node object
  * @returns {Promise} a promise that resolves to an object containing a node object
  */
-export async function putNode(nodeId, nodeType, nodeData) {
+export async function putNode({
+  nodeId,
+  nodeType,
+  nodeData,
+  state
+}) {
   // until we figure out a way to use transport keys in Frodo,
   // we'll have to drop those encrypted attributes.
   const cleanData = deleteDeepByKey(nodeData, '-encrypted');
-  const urlString = util.format(nodeURLTemplate, state.getHost(), getCurrentRealmPath(), nodeType, nodeId);
+  const urlString = util.format(nodeURLTemplate, state.getHost(), getCurrentRealmPath(state), nodeType, nodeId);
   const {
     data
-  } = await generateAmApi(getNodeApiConfig()).put(urlString, cleanData, {
+  } = await generateAmApi({
+    resource: getNodeApiConfig(),
+    state
+  }).put(urlString, cleanData, {
     withCredentials: true
   });
   return data;
@@ -106,11 +134,18 @@ export async function putNode(nodeId, nodeType, nodeData) {
  * @param {String} nodeType node type
  * @returns {Promise} a promise that resolves to an object containing a node object
  */
-export async function deleteNode(nodeId, nodeType) {
-  const urlString = util.format(nodeURLTemplate, state.getHost(), getCurrentRealmPath(), nodeType, nodeId);
+export async function deleteNode({
+  nodeId,
+  nodeType,
+  state
+}) {
+  const urlString = util.format(nodeURLTemplate, state.getHost(), getCurrentRealmPath(state), nodeType, nodeId);
   const {
     data
-  } = await generateAmApi(getNodeApiConfig()).delete(urlString, {
+  } = await generateAmApi({
+    resource: getNodeApiConfig(),
+    state
+  }).delete(urlString, {
     withCredentials: true
   });
   return data;

package/esm/api/NodeApi.test.mjs

@@ -29,14 +29,15 @@
  * Note: FRODO_DEBUG=1 is optional and enables debug logging for some output
  * in case things don't function as expected
  */
-import { NodeRaw } from '../index';
+import * as NodeApi from './NodeApi';
+import { state } from '../index';
 import { autoSetupPolly } from '../utils/AutoSetupPolly';
 autoSetupPolly();
 describe('NodeApi', () => {
   const node1 = {
-    id: '67693475-3a58-4e38-bcc6-037b3fe46a58',
     type: 'ValidatedUsernameNode',
     node: {
+      _id: '67693475-3a58-4e38-bcc6-037b3fe46a58',
       usernameAttribute: 'userName',
       validateInput: false,
       _type: {
@@ -90,9 +91,9 @@ describe('NodeApi', () => {
     }
   };
   const node4 = {
-    id: '23bab9d4-1663-450f-8a4b-680f44f54fd6',
     type: 'CreateObjectNode',
     node: {
+      _id: '23bab9d4-1663-450f-8a4b-680f44f54fd6',
       identityResource: 'managed/user',
       _type: {
         _id: 'CreateObjectNode',
@@ -113,39 +114,91 @@ describe('NodeApi', () => {
     if (process.env.FRODO_POLLY_MODE === 'record') {
       // setup node1 - delete if exists, then create
       try {
-        await NodeRaw.getNode(node1.id, node1.type);
-        await NodeRaw.deleteNode(node1.id, node1.type);
+        await NodeApi.getNode({
+          nodeId: node1.node._id,
+          nodeType: node1.type,
+          state
+        });
+        await NodeApi.deleteNode({
+          nodeId: node1.node._id,
+          nodeType: node1.type,
+          state
+        });
       } catch (error) {
         // ignore
       } finally {
-        await NodeRaw.putNode(node1.id, node1.type, node1.node);
+        await NodeApi.putNode({
+          nodeId: node1.node._id,
+          nodeType: node1.type,
+          nodeData: node1.node,
+          state
+        });
       }
       // setup node2 - delete if exists
       try {
-        await NodeRaw.getNode(node2.id, node2.type);
-        await NodeRaw.deleteNode(node2.id, node2.type);
+        await NodeApi.getNode({
+          nodeId: node2.id,
+          nodeType: node2.type,
+          state
+        });
+        await NodeApi.deleteNode({
+          nodeId: node2.id,
+          nodeType: node2.type,
+          state
+        });
       } catch (error) {
         // ignore
       } finally {
-        await NodeRaw.putNode(node2.id, node2.type, node2.node);
+        await NodeApi.putNode({
+          nodeId: node2.id,
+          nodeType: node2.type,
+          nodeData: node2.node,
+          state
+        });
       }
       // setup node3 - delete if exists, then create
       try {
-        await NodeRaw.getNode(node3.id, node3.type);
-        await NodeRaw.deleteNode(node3.id, node3.type);
+        await NodeApi.getNode({
+          nodeId: node3.id,
+          nodeType: node3.type,
+          state
+        });
+        await NodeApi.deleteNode({
+          nodeId: node3.id,
+          nodeType: node3.type,
+          state
+        });
       } catch (error) {
         // ignore
       } finally {
-        await NodeRaw.putNode(node3.id, node3.type, node3.node);
+        await NodeApi.putNode({
+          nodeId: node3.id,
+          nodeType: node3.type,
+          nodeData: node3.node,
+          state
+        });
       }
       // setup node4 - delete if exists, then create
       try {
-        await NodeRaw.getNode(node4.id, node4.type);
-        await NodeRaw.deleteNode(node4.id, node4.type);
+        await NodeApi.getNode({
+          nodeId: node4.node._id,
+          nodeType: node4.type,
+          state
+        });
+        await NodeApi.deleteNode({
+          nodeId: node4.node._id,
+          nodeType: node4.type,
+          state
+        });
       } catch (error) {
         // ignore
       } finally {
-        await NodeRaw.putNode(node4.id, node4.type, node4.node);
+        await NodeApi.putNode({
+          nodeId: node4.node._id,
+          nodeType: node4.type,
+          nodeData: node4.node,
+          state
+        });
       }
     }
   });
@@ -153,26 +206,58 @@ describe('NodeApi', () => {
   afterAll(async () => {
     if (process.env.FRODO_POLLY_MODE === 'record') {
       try {
-        await NodeRaw.getNode(node1.id, node1.type);
-        await NodeRaw.deleteNode(node1.id, node1.type);
+        await NodeApi.getNode({
+          nodeId: node1.node._id,
+          nodeType: node1.type,
+          state
+        });
+        await NodeApi.deleteNode({
+          nodeId: node1.node._id,
+          nodeType: node1.type,
+          state
+        });
       } catch (error) {
         // ignore
       }
       try {
-        await NodeRaw.getNode(node2.id, node2.type);
-        await NodeRaw.deleteNode(node2.id, node2.type);
+        await NodeApi.getNode({
+          nodeId: node2.id,
+          nodeType: node2.type,
+          state
+        });
+        await NodeApi.deleteNode({
+          nodeId: node2.id,
+          nodeType: node2.type,
+          state
+        });
       } catch (error) {
         // ignore
       }
       try {
-        await NodeRaw.getNode(node3.id, node3.type);
-        await NodeRaw.deleteNode(node3.id, node3.type);
+        await NodeApi.getNode({
+          nodeId: node3.id,
+          nodeType: node3.type,
+          state
+        });
+        await NodeApi.deleteNode({
+          nodeId: node3.id,
+          nodeType: node3.type,
+          state
+        });
       } catch (error) {
         // ignore
       }
       try {
-        await NodeRaw.getNode(node4.id, node4.type);
-        await NodeRaw.deleteNode(node4.id, node4.type);
+        await NodeApi.getNode({
+          nodeId: node4.node._id,
+          nodeType: node4.type,
+          state
+        });
+        await NodeApi.deleteNode({
+          nodeId: node4.node._id,
+          nodeType: node4.type,
+          state
+        });
       } catch (error) {
         // ignore
       }
@@ -180,43 +265,58 @@ describe('NodeApi', () => {
   });
   describe('getNodeTypes()', () => {
     test('0: Method is implemented', async () => {
-      expect(NodeRaw.getNodeTypes).toBeDefined();
+      expect(NodeApi.getNodeTypes).toBeDefined();
     });
     test('1: Get all node types', async () => {
-      const response = await NodeRaw.getNodeTypes();
+      const response = await NodeApi.getNodeTypes({
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
   describe('getNodes()', () => {
     test('0: Method is implemented', async () => {
-      expect(NodeRaw.getNodes).toBeDefined();
+      expect(NodeApi.getNodes).toBeDefined();
     });
     test('1: Get all nodes', async () => {
-      const response = await NodeRaw.getNodes();
+      const response = await NodeApi.getNodes({
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
   describe('getNodesByType()', () => {
     test('0: Method is implemented', async () => {
-      expect(NodeRaw.getNodesByType).toBeDefined();
+      expect(NodeApi.getNodesByType).toBeDefined();
     });
     test('1: Get all page nodes', async () => {
-      const response = await NodeRaw.getNodesByType('PageNode');
+      const response = await NodeApi.getNodesByType({
+        nodeType: 'PageNode',
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
   describe('getNode()', () => {
     test('0: Method is implemented', async () => {
-      expect(NodeRaw.getNode).toBeDefined();
+      expect(NodeApi.getNode).toBeDefined();
     });
-    test(`1: Get existing node [${node1.id} - ${node1.type}]`, async () => {
-      const response = await NodeRaw.getNode(node1.id, node1.type);
+    test(`1: Get existing node [${node1.node._id} - ${node1.type}]`, async () => {
+      const response = await NodeApi.getNode({
+        nodeId: node1.node._id,
+        nodeType: node1.type,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
     test('2: Get non-existing node [00000000-0000-0000-0000-000000000000 - PageNode]', async () => {
       expect.assertions(1);
       try {
-        await NodeRaw.getNode('00000000-0000-0000-0000-000000000000', 'PageNode');
+        await NodeApi.getNode({
+          nodeId: '00000000-0000-0000-0000-000000000000',
+          nodeType: 'PageNode',
+          state
+        });
       } catch (error) {
         expect(error.response.data).toMatchSnapshot();
       }
@@ -224,29 +324,47 @@ describe('NodeApi', () => {
   });
   describe('putNode()', () => {
     test('0: Method is implemented', async () => {
-      expect(NodeRaw.putNode).toBeDefined();
+      expect(NodeApi.putNode).toBeDefined();
     });
     test(`1: Create new node [${node2.id} - ${node2.type}]`, async () => {
-      const response = await NodeRaw.putNode(node2.id, node2.type, node2.node);
+      const response = await NodeApi.putNode({
+        nodeId: node2.id,
+        nodeType: node2.type,
+        nodeData: node2.node,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
     test(`2: Update existing node [${node3.id} - ${node3.type}]`, async () => {
-      const node = await NodeRaw.putNode(node3.id, node3.type, node3.node);
+      const node = await NodeApi.putNode({
+        nodeId: node3.id,
+        nodeType: node3.type,
+        nodeData: node3.node,
+        state
+      });
       expect(node).toMatchSnapshot();
     });
   });
   describe('deleteNode()', () => {
     test('0: Method is implemented', async () => {
-      expect(NodeRaw.deleteNode).toBeDefined();
+      expect(NodeApi.deleteNode).toBeDefined();
     });
-    test(`1: Delete existing node [${node4.id} - ${node4.type}]`, async () => {
-      const node = await NodeRaw.deleteNode(node4.id, node4.type);
+    test(`1: Delete existing node [${node4.node._id} - ${node4.type}]`, async () => {
+      const node = await NodeApi.deleteNode({
+        nodeId: node4.node._id,
+        nodeType: node4.type,
+        state
+      });
       expect(node).toMatchSnapshot();
     });
     test('2: Delete non-existing node [00000000-0000-0000-0000-000000000000 - PageNode]', async () => {
       expect.assertions(1);
       try {
-        await NodeRaw.deleteNode('00000000-0000-0000-0000-000000000000', 'PageNode');
+        await NodeApi.deleteNode({
+          nodeId: '00000000-0000-0000-0000-000000000000',
+          nodeType: 'PageNode',
+          state
+        });
       } catch (error) {
         expect(error.response.data).toMatchSnapshot();
       }

package/esm/api/OAuth2ClientApi.mjs

@@ -1,14 +1,11 @@
 import util from 'util';
 import { generateAmApi } from './BaseApi';
 import { deleteDeepByKey, getCurrentRealmPath } from './utils/ApiUtils';
-import * as state from '../shared/State';
 const oauth2ClientURLTemplate = '%s/json%s/realm-config/agents/OAuth2Client/%s';
 const oauth2ClientListURLTemplate = '%s/json%s/realm-config/agents/OAuth2Client?_queryFilter=true';
 const apiVersion = 'protocol=2.1,resource=1.0';
 const getApiConfig = () => {
-  const configPath = getCurrentRealmPath();
   return {
-    path: `${configPath}/realm-config/agents/OAuth2Client`,
     apiVersion
   };
 };
@@ -17,11 +14,16 @@ const getApiConfig = () => {
  * Get OAuth2 Clients
  * @returns {Promise<PagedResults>} a promise that resolves to a PagedResults object containing an array of oauth2client objects
  */
-export async function getOAuth2Clients() {
-  const urlString = util.format(oauth2ClientListURLTemplate, state.getHost(), getCurrentRealmPath());
+export async function getOAuth2Clients({
+  state
+}) {
+  const urlString = util.format(oauth2ClientListURLTemplate, state.getHost(), getCurrentRealmPath(state));
   const {
     data
-  } = await generateAmApi(getApiConfig()).get(urlString, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).get(urlString, {
     withCredentials: true
   });
   return data;
@@ -32,11 +34,17 @@ export async function getOAuth2Clients() {
  * @param {string} id client id
  * @returns {Promise<OAuth2ClientSkeleton>} a promise that resolves to an oauth2 client object
  */
-export async function getOAuth2Client(id) {
-  const urlString = util.format(oauth2ClientURLTemplate, state.getHost(), getCurrentRealmPath(), id);
+export async function getOAuth2Client({
+  id,
+  state
+}) {
+  const urlString = util.format(oauth2ClientURLTemplate, state.getHost(), getCurrentRealmPath(state), id);
   const {
     data
-  } = await generateAmApi(getApiConfig()).get(urlString, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).get(urlString, {
     withCredentials: true
   });
   return data;
@@ -48,16 +56,23 @@ export async function getOAuth2Client(id) {
  * @param {OAuth2ClientSkeleton} clientData oauth2client object
  * @returns {Promise<OAuth2ClientSkeleton>} a promise that resolves to an oauth2 client object
  */
-export async function putOAuth2Client(id, clientData) {
+export async function putOAuth2Client({
+  id,
+  clientData,
+  state
+}) {
   // until we figure out a way to use transport keys in Frodo,
   // we'll have to drop those encrypted attributes.
   const client = deleteDeepByKey(clientData, '-encrypted');
   delete client._provider;
   delete client._rev;
-  const urlString = util.format(oauth2ClientURLTemplate, state.getHost(), getCurrentRealmPath(), id);
+  const urlString = util.format(oauth2ClientURLTemplate, state.getHost(), getCurrentRealmPath(state), id);
   const {
     data
-  } = await generateAmApi(getApiConfig()).put(urlString, client, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).put(urlString, client, {
     withCredentials: true
   });
   return data;
@@ -68,11 +83,17 @@ export async function putOAuth2Client(id, clientData) {
  * @param {string} id OAuth2 Client
  * @returns {Promise<OAuth2ClientSkeleton>} a promise that resolves to an oauth2client object
  */
-export async function deleteOAuth2Client(id) {
-  const urlString = util.format(oauth2ClientURLTemplate, state.getHost(), getCurrentRealmPath(), id);
+export async function deleteOAuth2Client({
+  id,
+  state
+}) {
+  const urlString = util.format(oauth2ClientURLTemplate, state.getHost(), getCurrentRealmPath(state), id);
   const {
     data
-  } = await generateAmApi(getApiConfig()).delete(urlString, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).delete(urlString, {
     withCredentials: true
   });
   return data;