@rockcarver/frodo-lib 1.0.0 → 2.0.0-1

package/esm/api/AuthenticateApi.test.mjs

@@ -32,7 +32,8 @@
  * Note: FRODO_DEBUG=1 is optional and enables debug logging for some output
  * in case things don't function as expected
  */
-import { AuthenticateRaw, state } from '../index';
+import * as AuthenticateApi from './AuthenticateApi';
+import { state } from '../index';
 import { autoSetupPolly, defaultMatchRequestsBy } from '../utils/AutoSetupPolly';
 
 // need to modify the default matching rules to allow the mocking to work for an authentication flow.
@@ -44,7 +45,7 @@ autoSetupPolly(matchConfig);
 describe('AuthenticateApi', () => {
   describe('step()', () => {
     test('0: Method is implemented', async () => {
-      expect(AuthenticateRaw.step).toBeDefined();
+      expect(AuthenticateApi.step).toBeDefined();
     });
     test("1: Single step login journey 'PasswordGrant'", async () => {
       state.setHost(process.env.FRODO_HOST || 'https://openam-frodo-dev.forgeblocks.com/am');
@@ -58,7 +59,12 @@ describe('AuthenticateApi', () => {
           'X-OpenAM-Password': state.getPassword()
         }
       };
-      const response1 = await AuthenticateRaw.step({}, config, state.getRealm());
+      const response1 = await AuthenticateApi.step({
+        body: {},
+        config,
+        realm: state.getRealm(),
+        state
+      });
       expect(response1).toMatchSnapshot();
     });
     test("2: Two step login journey 'PasswordGrant'", async () => {
@@ -67,13 +73,26 @@ describe('AuthenticateApi', () => {
       state.setUsername(process.env.FRODO_USERNAME || 'mockUser');
       state.setPassword(process.env.FRODO_PASSWORD || 'mockPassword');
       state.setAuthenticationService(process.env.FRODO_AUTHENTICATION_SERVICE || 'PasswordGrant');
-      const response1 = await AuthenticateRaw.step({}, {}, state.getRealm());
+      const response1 = await AuthenticateApi.step({
+        body: {},
+        config: {},
+        realm: state.getRealm(),
+        state
+      });
       expect(response1).toMatchSnapshot();
-      const body = AuthenticateRaw.fillCallbacks(response1, {
-        IDToken1: state.getUsername(),
-        IDToken2: state.getPassword()
+      const body = AuthenticateApi.fillCallbacks({
+        response: response1,
+        map: {
+          IDToken1: state.getUsername(),
+          IDToken2: state.getPassword()
+        }
+      });
+      const response2 = await AuthenticateApi.step({
+        body,
+        config: {},
+        realm: state.getRealm(),
+        state
       });
-      const response2 = await AuthenticateRaw.step(body, {}, state.getRealm());
       expect(response2).toMatchSnapshot();
     });
   });

package/esm/api/BaseApi.mjs

@@ -4,7 +4,6 @@ import axiosRetry from 'axios-retry';
 import HttpsProxyAgent from 'https-proxy-agent';
 import url from 'url';
 import fs from 'fs';
-import * as state from '../shared/State';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { curlirizeMessage, printMessage } from '../ops/utils/Console';
@@ -46,12 +45,12 @@ function getHttpAgent() {
 
 /**
  * Helper method to create properly configured httpsAgent
- * @returns {any} appropriate httpsAgent
+ * @returns {Agent.HttpsAgent} appropriate httpsAgent
  */
-function getHttpsAgent() {
+function getHttpsAgent(allowInsecureConnection) {
   if (httpsAgent) return httpsAgent;
   const options = {
-    rejectUnauthorized: !state.getAllowInsecureConnection()
+    rejectUnauthorized: !allowInsecureConnection
   };
   const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
   if (httpsProxy) {
@@ -61,7 +60,7 @@ function getHttpsAgent() {
     options['host'] = parsed.hostname;
     options['port'] = parsed.port;
     options['protocol'] = parsed.protocol;
-    options.rejectUnauthorized = !state.getAllowInsecureConnection();
+    options.rejectUnauthorized = !allowInsecureConnection;
     httpsAgent = HttpsProxyAgent(options);
     return httpsAgent;
   }
@@ -109,7 +108,11 @@ function curlirize(request) {
  *
  * @returns {AxiosInstance}
  */
-export function generateAmApi(resource, requestOverride = {}) {
+export function generateAmApi({
+  resource,
+  requestOverride = {},
+  state
+}) {
   let headers = {
     'User-Agent': userAgent,
     'X-ForgeRock-TransactionId': transactionId,
@@ -142,7 +145,7 @@ export function generateAmApi(resource, requestOverride = {}) {
       ...state.getAuthenticationHeaderOverrides()
     },
     httpAgent: getHttpAgent(),
-    httpsAgent: getHttpsAgent(),
+    httpsAgent: getHttpsAgent(state.getAllowInsecureConnection()),
     proxy: getProxy()
   };
   const request = axios.create(requestDetails);
@@ -162,7 +165,11 @@ export function generateAmApi(resource, requestOverride = {}) {
  *
  * @returns {AxiosInstance}
  */
-export function generateOauth2Api(resource, requestOverride = {}) {
+export function generateOauth2Api({
+  resource,
+  requestOverride = {},
+  state
+}) {
   let headers = {
     'User-Agent': userAgent,
     'X-ForgeRock-TransactionId': transactionId,
@@ -194,7 +201,7 @@ export function generateOauth2Api(resource, requestOverride = {}) {
       ...state.getAuthenticationHeaderOverrides()
     },
     httpAgent: getHttpAgent(),
-    httpsAgent: getHttpsAgent(),
+    httpsAgent: getHttpsAgent(state.getAllowInsecureConnection()),
     proxy: getProxy()
   };
   const request = axios.create(requestDetails);
@@ -213,7 +220,10 @@ export function generateOauth2Api(resource, requestOverride = {}) {
  *
  * @returns {AxiosInstance}
  */
-export function generateIdmApi(requestOverride = {}) {
+export function generateIdmApi({
+  requestOverride = {},
+  state
+}) {
   const requestDetails = {
     // baseURL: getTenantURL(storage.session.getTenant()),
     timeout,
@@ -228,7 +238,7 @@ export function generateIdmApi(requestOverride = {}) {
     },
     ...requestOverride,
     httpAgent: getHttpAgent(),
-    httpsAgent: getHttpsAgent(),
+    httpsAgent: getHttpsAgent(state.getAllowInsecureConnection()),
     proxy: getProxy()
   };
 
@@ -254,7 +264,10 @@ export function generateIdmApi(requestOverride = {}) {
  *
  * @returns {AxiosInstance}
  */
-export function generateLogKeysApi(requestOverride = {}) {
+export function generateLogKeysApi({
+  requestOverride = {},
+  state
+}) {
   const headers = {
     'User-Agent': userAgent,
     'Content-Type': 'application/json',
@@ -269,7 +282,7 @@ export function generateLogKeysApi(requestOverride = {}) {
     headers,
     ...requestOverride,
     httpAgent: getHttpAgent(),
-    httpsAgent: getHttpsAgent(),
+    httpsAgent: getHttpsAgent(state.getAllowInsecureConnection()),
     proxy: getProxy()
   };
   const request = axios.create(requestDetails);
@@ -288,7 +301,10 @@ export function generateLogKeysApi(requestOverride = {}) {
  *
  * @returns {AxiosInstance}
  */
-export function generateLogApi(requestOverride = {}) {
+export function generateLogApi({
+  requestOverride = {},
+  state
+}) {
   const headers = {
     'User-Agent': userAgent,
     'X-API-Key': state.getLogApiKey(),
@@ -300,7 +316,7 @@ export function generateLogApi(requestOverride = {}) {
     headers,
     ...requestOverride,
     httpAgent: getHttpAgent(),
-    httpsAgent: getHttpsAgent(),
+    httpsAgent: getHttpsAgent(state.getAllowInsecureConnection()),
     proxy: getProxy()
   };
   const request = axios.create(requestDetails);
@@ -319,7 +335,11 @@ export function generateLogApi(requestOverride = {}) {
  *
  * @returns {AxiosInstance}
  */
-export function generateEnvApi(resource, requestOverride = {}) {
+export function generateEnvApi({
+  resource,
+  requestOverride = {},
+  state
+}) {
   const headers = {
     'User-Agent': userAgent,
     'Content-Type': 'application/json',
@@ -338,7 +358,7 @@ export function generateEnvApi(resource, requestOverride = {}) {
     headers,
     ...requestOverride,
     httpAgent: getHttpAgent(),
-    httpsAgent: getHttpsAgent(),
+    httpsAgent: getHttpsAgent(state.getAllowInsecureConnection()),
     proxy: getProxy()
   };
   const request = axios.create(requestDetails);
@@ -357,7 +377,11 @@ export function generateEnvApi(resource, requestOverride = {}) {
  *
  * @returns {AxiosInstance}
  */
-export function generateReleaseApi(baseUrl, requestOverride = {}) {
+export function generateReleaseApi({
+  baseUrl,
+  requestOverride = {},
+  state
+}) {
   const requestDetails = {
     baseURL: baseUrl,
     timeout,
@@ -367,7 +391,7 @@ export function generateReleaseApi(baseUrl, requestOverride = {}) {
     },
     ...requestOverride,
     httpAgent: getHttpAgent(),
-    httpsAgent: getHttpsAgent(),
+    httpsAgent: getHttpsAgent(state.getAllowInsecureConnection()),
     proxy: getProxy()
   };
   const request = axios.create(requestDetails);

package/esm/api/CirclesOfTrustApi.mjs

@@ -2,14 +2,12 @@ import util from 'util';
 import _ from 'lodash';
 import { generateAmApi } from './BaseApi';
 import { getCurrentRealmPath } from './utils/ApiUtils';
-import * as state from '../shared/State';
 const circleOfTrustByIdURLTemplate = '%s/json%s/realm-config/federation/circlesoftrust/%s';
 const createCircleOfTrustURLTemplate = '%s/json%s/realm-config/federation/circlesoftrust/?_action=create';
 const queryAllCirclesOfTrustURLTemplate = '%s/json%s/realm-config/federation/circlesoftrust?_queryFilter=true';
 const apiVersion = 'protocol=2.1,resource=1.0';
 const getApiConfig = () => {
   return {
-    path: `/json${getCurrentRealmPath()}/realm-config/federation/circlesoftrust`,
     apiVersion
   };
 };
@@ -18,11 +16,16 @@ const getApiConfig = () => {
  * Get all SAML2 circles of trust
  * @returns {Promise} a promise that resolves to an array of circles of trust objects
  */
-export async function getCirclesOfTrust() {
-  const urlString = util.format(queryAllCirclesOfTrustURLTemplate, state.getHost(), getCurrentRealmPath());
+export async function getCirclesOfTrust({
+  state
+}) {
+  const urlString = util.format(queryAllCirclesOfTrustURLTemplate, state.getHost(), getCurrentRealmPath(state));
   const {
     data
-  } = await generateAmApi(getApiConfig()).get(urlString, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).get(urlString, {
     withCredentials: true
   });
   return data;
@@ -33,11 +36,17 @@ export async function getCirclesOfTrust() {
  * @param {String} cotId Circle of trust id/name
  * @returns {Promise} a promise that resolves to a saml2 circle of trust object
  */
-export async function getCircleOfTrust(cotId) {
-  const urlString = util.format(circleOfTrustByIdURLTemplate, state.getHost(), getCurrentRealmPath(), cotId);
+export async function getCircleOfTrust({
+  cotId,
+  state
+}) {
+  const urlString = util.format(circleOfTrustByIdURLTemplate, state.getHost(), getCurrentRealmPath(state), cotId);
   const {
     data
-  } = await generateAmApi(getApiConfig()).get(urlString, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).get(urlString, {
     withCredentials: true
   });
   return data;
@@ -45,15 +54,21 @@ export async function getCircleOfTrust(cotId) {
 
 /**
  * Create a SAML2 circle of trust
- * @param {Object} cotData Object representing a SAML circle of trust
+ * @param {CircleOfTrustSkeleton} cotData Object representing a SAML circle of trust
  * @returns {Promise} a promise that resolves to a saml2 circle of trust object
  */
-export async function createCircleOfTrust(cotData) {
+export async function createCircleOfTrust({
+  cotData,
+  state
+}) {
   const postData = _.cloneDeep(cotData);
-  const urlString = util.format(createCircleOfTrustURLTemplate, state.getHost(), getCurrentRealmPath());
+  const urlString = util.format(createCircleOfTrustURLTemplate, state.getHost(), getCurrentRealmPath(state));
   const {
     data
-  } = await generateAmApi(getApiConfig()).post(urlString, postData, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).post(urlString, postData, {
     withCredentials: true
   });
   return data;
@@ -61,15 +76,22 @@ export async function createCircleOfTrust(cotData) {
 
 /**
  * Update SAML2 circle of trust
- * @param {String} cotId Entity provider location (hosted or remote)
- * @param {Object} cotData Object representing a SAML2 circle of trust
+ * @param {string} cotId Entity provider location (hosted or remote)
+ * @param {CircleOfTrustSkeleton} cotData Object representing a SAML2 circle of trust
  * @returns {Promise} a promise that resolves to a saml2 circle of trust object
  */
-export async function updateCircleOfTrust(cotId, cotData) {
-  const urlString = util.format(circleOfTrustByIdURLTemplate, state.getHost(), getCurrentRealmPath(), cotId);
+export async function updateCircleOfTrust({
+  cotId,
+  cotData,
+  state
+}) {
+  const urlString = util.format(circleOfTrustByIdURLTemplate, state.getHost(), getCurrentRealmPath(state), cotId);
   const {
     data
-  } = await generateAmApi(getApiConfig()).put(urlString, cotData, {
+  } = await generateAmApi({
+    resource: getApiConfig(),
+    state
+  }).put(urlString, cotData, {
     withCredentials: true
   });
   return data;

package/esm/api/IdmConfigApi.mjs

@@ -1,7 +1,6 @@
 import util from 'util';
 import { generateIdmApi } from './BaseApi';
 import { getTenantURL } from './utils/ApiUtils';
-import * as state from '../shared/State';
 const idmAllConfigURLTemplate = '%s/openidm/config';
 const idmConfigURLTemplate = '%s/openidm/config/%s';
 const idmConfigEntityQueryTemplate = '%s/openidm/config?_queryFilter=%s';
@@ -11,11 +10,15 @@ const idmManagedObjectURLTemplate = '%s/openidm/managed/%s?_queryFilter=true&_pa
  * Get all IDM config entities
  * @returns {Promise} a promise that resolves to all IDM config entities
  */
-export async function getAllConfigEntities() {
+export async function getAllConfigEntities({
+  state
+}) {
   const urlString = util.format(idmAllConfigURLTemplate, getTenantURL(state.getHost()));
   const {
     data
-  } = await generateIdmApi().get(urlString);
+  } = await generateIdmApi({
+    state
+  }).get(urlString);
   return data;
 }
 
@@ -24,11 +27,16 @@ export async function getAllConfigEntities() {
  * @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) {
+export async function getConfigEntitiesByType({
+  type,
+  state
+}) {
   const urlString = util.format(idmConfigEntityQueryTemplate, getTenantURL(state.getHost()), encodeURIComponent(`_id sw '${type}'`));
   const {
     data
-  } = await generateIdmApi().get(urlString);
+  } = await generateIdmApi({
+    state
+  }).get(urlString);
   return data;
 }
 
@@ -37,11 +45,16 @@ export async function getConfigEntitiesByType(type) {
  * @param {string} entityId the desired config entity
  * @returns {Promise<unknown>} a promise that resolves to an IDM config entity
  */
-export async function getConfigEntity(entityId) {
+export async function getConfigEntity({
+  entityId,
+  state
+}) {
   const urlString = util.format(idmConfigURLTemplate, getTenantURL(state.getHost()), entityId);
   const {
     data
-  } = await generateIdmApi().get(urlString);
+  } = await generateIdmApi({
+    state
+  }).get(urlString);
   return data;
 }
 
@@ -51,12 +64,18 @@ export async function getConfigEntity(entityId) {
  * @param {string} entityData config entity object
  * @returns {Promise<unknown>} a promise that resolves to an IDM config entity
  */
-export async function putConfigEntity(entityId, entityData) {
+export async function putConfigEntity({
+  entityId,
+  entityData,
+  state
+}) {
   const urlString = util.format(idmConfigURLTemplate, getTenantURL(state.getHost()), entityId);
   try {
     const {
       data
-    } = await generateIdmApi().put(urlString, entityData);
+    } = await generateIdmApi({
+      state
+    }).put(urlString, entityData);
     return data;
   } catch (error) {
     throw Error(`Could not put config entity ${entityId}: ${error}`);
@@ -68,11 +87,16 @@ export async function putConfigEntity(entityId, entityData) {
  * @param {string} entityId config entity id
  * @returns {Promise<unknown>} a promise that resolves to an IDM config entity
  */
-export async function deleteConfigEntity(entityId) {
+export async function deleteConfigEntity({
+  entityId,
+  state
+}) {
   const urlString = util.format(idmConfigURLTemplate, getTenantURL(state.getHost()), entityId);
   const {
     data
-  } = await generateIdmApi().delete(urlString, {
+  } = await generateIdmApi({
+    state
+  }).delete(urlString, {
     withCredentials: true
   });
   return data;
@@ -85,13 +109,20 @@ export async function deleteConfigEntity(entityId) {
  * @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) {
+export async function queryAllManagedObjectsByType({
+  type,
+  fields = [],
+  pageCookie = undefined,
+  state
+}) {
   const fieldsParam = fields.length > 0 ? `&_fields=${fields.join(',')}` : '&_fields=_id';
   const urlTemplate = pageCookie ? `${idmManagedObjectURLTemplate}${fieldsParam}&_pagedResultsCookie=${encodeURIComponent(pageCookie)}` : `${idmManagedObjectURLTemplate}${fieldsParam}`;
   const urlString = util.format(urlTemplate, getTenantURL(state.getHost()), type);
   const {
     data
-  } = await generateIdmApi().get(urlString);
+  } = await generateIdmApi({
+    state
+  }).get(urlString);
   return data;
 }
 //# sourceMappingURL=IdmConfigApi.js.map

package/esm/api/IdmSystemApi.mjs

@@ -1,17 +1,21 @@
 import util from 'util';
 import { generateIdmApi } from './BaseApi';
 import { getTenantURL } from './utils/ApiUtils';
-import * as state from '../shared/State';
 const testConnectorServersURLTemplate = '%s/openidm/system?_action=testConnectorServers';
 /**
  * Test connector servers
  * @returns {Promise<TestConnectorServersInterface>} a promise that resolves to a TestConnectorServersInterface object
  */
-export async function testConnectorServers() {
+export async function testConnectorServers({
+  state
+}) {
   const urlString = util.format(testConnectorServersURLTemplate, getTenantURL(state.getHost()));
   const {
     data
-  } = await generateIdmApi().post(urlString);
+  } = await generateIdmApi({
+    state,
+    requestOverride: {}
+  }).post(urlString);
   return data;
 }
 //# sourceMappingURL=IdmSystemApi.js.map

package/esm/api/ManagedObjectApi.mjs

@@ -1,7 +1,5 @@
 import util from 'util';
 import { generateIdmApi } from './BaseApi';
-import { getTenantURL } from './utils/ApiUtils';
-import * as state from '../shared/State';
 const managedObjectURLTemplate = '%s/openidm/managed/%s';
 const createManagedObjectURLTemplate = '%s/openidm/managed/%s?_action=create';
 const managedObjectByIdURLTemplate = '%s/openidm/managed/%s/%s';
@@ -9,56 +7,82 @@ const managedObjectQueryAllURLTemplate = `${managedObjectURLTemplate}?_queryFilt
 
 /**
  * Get managed object
+ * @param {string} baseUrl tenant base URL
  * @param {string} type managed object type, e.g. alpha_user or user
  * @param {string} id managed object id
  * @param {string[]} id array of fields to include
+ * @param {State} state library state
  * @returns {Promise<IdObjectSkeletonInterface>} a promise that resolves to an ObjectSkeletonInterface
  */
-export async function getManagedObject(type, id, fields = ['*']) {
+export async function getManagedObject({
+  baseUrl,
+  type,
+  id,
+  fields = ['*'],
+  state
+}) {
   const fieldsParam = `_fields=${fields.join(',')}`;
-  const urlString = util.format(`${managedObjectByIdURLTemplate}?${fieldsParam}`, getTenantURL(state.getHost()), type, id);
+  const urlString = util.format(`${managedObjectByIdURLTemplate}?${fieldsParam}`, baseUrl, type, id);
   const {
     data
-  } = await generateIdmApi().get(urlString);
+  } = await generateIdmApi({
+    requestOverride: {},
+    state
+  }).get(urlString);
   return data;
 }
 
 /**
  * Create managed object with server-generated id
+ * @param {string} baseUrl tenant base URL
  * @param {string} moType managed object type
  * @param {any} moData managed object data
+ * @param {State} state library state
  * @returns {Promise<IdObjectSkeletonInterface>} a promise that resolves to an object containing a managed object
  */
-export async function createManagedObject(moType, moData) {
-  const urlString = util.format(createManagedObjectURLTemplate, getTenantURL(state.getHost()), moType);
+export async function createManagedObject(baseUrl, moType, moData, state) {
+  const urlString = util.format(createManagedObjectURLTemplate, baseUrl, moType);
   const {
     data
-  } = await generateIdmApi().post(urlString, moData);
+  } = await generateIdmApi({
+    requestOverride: {},
+    state
+  }).post(urlString, moData);
   return data;
 }
 
 /**
  * Create or update managed object
- * @param {String} id managed object id
- * @param {String} data managed object
- * @returns {Promise} a promise that resolves to an object containing a managed object
+ * @param {string} baseUrl tenant base URL
+ * @param {string} id managed object id
+ * @param {string} moData managed object
+ * @param {State} state library state
+ * @returns {Promise<IdObjectSkeletonInterface>} a promise that resolves to an object containing a managed object
  */
-export async function putManagedObject(type, id, data) {
-  const urlString = util.format(managedObjectByIdURLTemplate, getTenantURL(state.getHost()), type, id);
-  return generateIdmApi().put(urlString, data);
+export async function putManagedObject(baseUrl, type, id, moData, state) {
+  const urlString = util.format(managedObjectByIdURLTemplate, baseUrl, type, id);
+  return generateIdmApi({
+    requestOverride: {},
+    state
+  }).put(urlString, moData);
 }
 
 /**
  * Query managed objects
- * @param {String} type managed object type
- * @param {String} fields fields to retrieve
- * @param {String} pageCookie paged results cookie
+ * @param {string} baseUrl tenant base URL
+ * @param {string} type managed object type
+ * @param {string} fields fields to retrieve
+ * @param {string} pageCookie paged results cookie
+ * @param {State} state library state
  * @returns {Promise} a promise that resolves to an object containing managed objects of the desired type
  */
-export async function queryAllManagedObjectsByType(type, fields, pageCookie) {
+export async function queryAllManagedObjectsByType(baseUrl, type, fields, pageCookie, state) {
   const fieldsParam = fields.length > 0 ? `&_fields=${fields.join(',')}` : '&_fields=_id';
   const urlTemplate = pageCookie ? `${managedObjectQueryAllURLTemplate}${fieldsParam}&_pagedResultsCookie=${pageCookie}` : `${managedObjectQueryAllURLTemplate}${fieldsParam}`;
-  const urlString = util.format(urlTemplate, getTenantURL(state.getHost()), type);
-  return generateIdmApi().get(urlString);
+  const urlString = util.format(urlTemplate, baseUrl, type);
+  return generateIdmApi({
+    requestOverride: {},
+    state
+  }).get(urlString);
 }
 //# sourceMappingURL=ManagedObjectApi.js.map