@rockcarver/frodo-lib 0.11.0

package/src/api/CirclesOfTrustApi.js

@@ -0,0 +1,87 @@
+import util from 'util';
+import _ from 'lodash';
+import { generateAmApi } from './BaseApi.js';
+import { getCurrentRealmPath } from './utils/ApiUtils.js';
+import storage from '../storage/SessionStorage.js';
+
+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 = () => {
+  const configPath = getCurrentRealmPath();
+  return {
+    path: `${configPath}/realm-config/federation/circlesoftrust`,
+    apiVersion,
+  };
+};
+
+/**
+ * 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,
+    storage.session.getTenant(),
+    getCurrentRealmPath()
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get SAML2 circle of trust by id/name
+ * @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,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    cotId
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Create a SAML2 circle of trust
+ * @param {Object} 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) {
+  const postData = _.cloneDeep(cotData);
+  const urlString = util.format(
+    createCircleOfTrustURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(storage.session.getRealm())
+  );
+  return generateAmApi(getApiConfig()).post(urlString, postData, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Update SAML2 circle of trust
+ * @param {String} cotId Entity provider location (hosted or remote)
+ * @param {Object} 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,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    cotId
+  );
+  return generateAmApi(getApiConfig()).put(urlString, cotData, {
+    withCredentials: true,
+  });
+}

package/src/api/EmailTemplateApi.js

@@ -0,0 +1,37 @@
+import {
+  getConfigEntitiesByType,
+  getConfigEntity,
+  putConfigEntity,
+} from './IdmConfigApi.js';
+
+/**
+ * Email template type key used to build the IDM id: 'emailTemplate/<id>'
+ */
+export const EMAIL_TEMPLATE_TYPE = 'emailTemplate';
+
+/**
+ * Get all email templates
+ * @returns {Promise} a promise that resolves to an object containing an array of email template objects
+ */
+export async function getEmailTemplates() {
+  return getConfigEntitiesByType(EMAIL_TEMPLATE_TYPE);
+}
+
+/**
+ * Get email template
+ * @param {String} id id/name of the email template without the type prefix
+ * @returns {Promise} a promise that resolves to an object containing the email template object
+ */
+export async function getEmailTemplate(id) {
+  return getConfigEntity(`${EMAIL_TEMPLATE_TYPE}/${id}`);
+}
+
+/**
+ * Put email template
+ * @param {String} id id/name of the email template without the type prefix
+ * @param {Object} data email template object
+ * @returns {Promise} a promise that resolves to an object containing the email template object
+ */
+export async function putEmailTemplate(id, data) {
+  return putConfigEntity(`${EMAIL_TEMPLATE_TYPE}/${id}`, data);
+}

package/src/api/IdmConfigApi.js

@@ -0,0 +1,88 @@
+import util from 'util';
+import { generateIdmApi } from './BaseApi.js';
+import { getTenantURL } from './utils/ApiUtils.js';
+import storage from '../storage/SessionStorage.js';
+
+const idmAllConfigURLTemplate = '%s/openidm/config';
+const idmConfigURLTemplate = '%s/openidm/config/%s';
+const idmConfigEntityQueryTemplate = '%s/openidm/config?_queryFilter=%s';
+const idmManagedObjectURLTemplate =
+  '%s/openidm/managed/%s?_queryFilter=true&_pageSize=10000';
+
+/**
+ * Get all IDM config entities
+ * @returns {Promise} a promise that resolves to an object containing all IDM config entities
+ */
+export async function getAllConfigEntities() {
+  const urlString = util.format(
+    idmAllConfigURLTemplate,
+    getTenantURL(storage.session.getTenant())
+  );
+  return generateIdmApi().get(urlString);
+}
+
+/**
+ * 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) {
+  const urlString = util.format(
+    idmConfigEntityQueryTemplate,
+    getTenantURL(storage.session.getTenant()),
+    encodeURIComponent(`_id sw '${type}'`)
+  );
+  return generateIdmApi().get(urlString);
+}
+
+/**
+ * Get an IDM config entity
+ * @param {String} id the desired config entity
+ * @returns {Promise} a promise that resolves to an object containing an IDM config entity
+ */
+export async function getConfigEntity(id) {
+  const urlString = util.format(
+    idmConfigURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id
+  );
+  return generateIdmApi().get(urlString);
+}
+
+/**
+ * Put IDM config entity
+ * @param {String} id config entity id
+ * @param {String} data config entity object
+ * @returns {Promise} a promise that resolves to an object containing an IDM config entity
+ */
+export async function putConfigEntity(id, data) {
+  const urlString = util.format(
+    idmConfigURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id
+  );
+  return generateIdmApi().put(urlString, data);
+}
+
+/**
+ * Query managed objects
+ * @param {String} type managed object type
+ * @param {[String]} fields fields to retrieve
+ * @param {String} pageCookie paged results cookie
+ * @returns {Promise} a promise that resolves to an object containing managed objects of the desired type
+ */
+export async function queryAllManagedObjectsByType(type, fields, pageCookie) {
+  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(storage.session.getTenant()),
+    type
+  );
+  return generateIdmApi().get(urlString);
+}

package/src/api/LogApi.js

@@ -0,0 +1,45 @@
+import util from 'util';
+import { generateLogApi, generateLogKeysApi } from './BaseApi.js';
+import { getTenantURL } from './utils/ApiUtils.js';
+import storage from '../storage/SessionStorage.js';
+
+const logsTailURLTemplate = '%s/monitoring/logs/tail?source=%s';
+const logsSourcesURLTemplate = '%s/monitoring/logs/sources';
+const logsCreateAPIKeyAndSecretURLTemplate = '%s/keys?_action=create';
+const logsGetAPIKeysURLTemplate = '%s/keys';
+
+export async function tail(source, cookie) {
+  let urlString = util.format(
+    logsTailURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    encodeURIComponent(source)
+  );
+  if (cookie) {
+    urlString += `&_pagedResultsCookie=${encodeURIComponent(cookie)}`;
+  }
+  return generateLogApi().get(urlString);
+}
+
+export async function getAPIKeys() {
+  const urlString = util.format(
+    logsGetAPIKeysURLTemplate,
+    getTenantURL(storage.session.getTenant())
+  );
+  return generateLogKeysApi().get(urlString);
+}
+
+export async function getSources() {
+  const urlString = util.format(
+    logsSourcesURLTemplate,
+    getTenantURL(storage.session.getTenant())
+  );
+  return generateLogApi().get(urlString);
+}
+
+export async function createAPIKeyAndSecret(keyName) {
+  const urlString = util.format(
+    logsCreateAPIKeyAndSecretURLTemplate,
+    getTenantURL(storage.session.getTenant())
+  );
+  return generateLogKeysApi().post(urlString, { name: keyName });
+}

package/src/api/ManagedObjectApi.js

@@ -0,0 +1,62 @@
+import util from 'util';
+import { generateIdmApi } from './BaseApi.js';
+import { getTenantURL } from './utils/ApiUtils.js';
+import storage from '../storage/SessionStorage.js';
+
+const managedObjectURLTemplate = '%s/openidm/managed/%s';
+const managedObjectByIdURLTemplate = '%s/openidm/managed/%s/%s';
+const managedObjectQueryAllURLTemplate = `${managedObjectURLTemplate}?_queryFilter=true&_pageSize=10000`;
+
+/**
+ * Get managed object
+ * @param {String} id managed object id
+ * @returns {Promise} a promise that resolves to an object containing a managed object
+ */
+export async function getManagedObject(type, id, fields) {
+  const fieldsParam =
+    fields.length > 0 ? `_fields=${fields.join(',')}` : '_fields=*';
+  const urlString = util.format(
+    `${managedObjectByIdURLTemplate}?${fieldsParam}`,
+    getTenantURL(storage.session.getTenant()),
+    type,
+    id
+  );
+  return generateIdmApi().get(urlString);
+}
+
+/**
+ * Put 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
+ */
+export async function putManagedObject(type, id, data) {
+  const urlString = util.format(
+    managedObjectByIdURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    type,
+    id
+  );
+  return generateIdmApi().put(urlString, data);
+}
+
+/**
+ * Query managed objects
+ * @param {String} type managed object type
+ * @param {String} fields fields to retrieve
+ * @param {String} pageCookie paged results cookie
+ * @returns {Promise} a promise that resolves to an object containing managed objects of the desired type
+ */
+export async function queryAllManagedObjectsByType(type, fields, pageCookie) {
+  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(storage.session.getTenant()),
+    type
+  );
+  return generateIdmApi().get(urlString);
+}

package/src/api/OAuth2ClientApi.js

@@ -0,0 +1,69 @@
+import util from 'util';
+import { generateAmApi } from './BaseApi.js';
+import { getCurrentRealmPath } from './utils/ApiUtils.js';
+import storage from '../storage/SessionStorage.js';
+
+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,
+  };
+};
+
+/**
+ * Get OAuth2 Clients
+ * @returns {Promise} a promise that resolves to an object containing an array of oauth2client objects
+ */
+export async function getOAuth2Clients() {
+  const urlString = util.format(
+    oauth2ClientListURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath()
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get OAuth2 Client
+ * @param {String} id client id
+ * @returns {Promise} a promise that resolves to an object containing an oauth2client object
+ */
+export async function getOAuth2Client(id) {
+  const urlString = util.format(
+    oauth2ClientURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    id
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Put OAuth2 Client
+ * @param {String} id client id
+ * @param {Object} data oauth2client object
+ * @returns {Promise} a promise that resolves to an object containing an oauth2client object
+ */
+export async function putOAuth2Client(id, data) {
+  const client = data;
+  delete client._provider;
+  delete client._rev;
+  const urlString = util.format(
+    oauth2ClientURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(storage.session.getRealm()),
+    id
+  );
+  return generateAmApi(getApiConfig()).put(urlString, client, {
+    withCredentials: true,
+  });
+}

package/src/api/OAuth2OIDCApi.js

@@ -0,0 +1,73 @@
+import util from 'util';
+import qs from 'qs';
+import { generateOauth2Api } from './BaseApi.js';
+import { getCurrentRealmPath } from './utils/ApiUtils.js';
+import storage from '../storage/SessionStorage.js';
+import { encode } from './utils/Base64.js';
+
+const authorizeUrlTemplate = '%s/oauth2%s/authorize';
+const accessTokenUrlTemplate = '%s/oauth2%s/access_token';
+const apiVersion = 'protocol=2.1,resource=1.0';
+const getApiConfig = () => ({
+  apiVersion,
+});
+
+/**
+ * Perform the authorization step of the authorization code grant flow
+ * @param {String} data body form data
+ * @param {Object} config axios request config object
+ * @returns {Promise} a promise resolving to an object containing the authorization server response object
+ */
+export async function authorize(data, config = {}) {
+  const authorizeURL = util.format(
+    authorizeUrlTemplate,
+    storage.session.getTenant(),
+    ''
+  );
+  return generateOauth2Api(getApiConfig()).post(authorizeURL, data, config);
+}
+
+/**
+ * Perform access token request step of the authorization code grant flow
+ * @param {*} data body form data
+ * @param {*} config config axios request config object
+ * @returns {Promise} a promise resolving to an object containing the authorization server response object containing the access token
+ */
+export async function accessToken(data, config = {}) {
+  const accessTokenURL = util.format(
+    accessTokenUrlTemplate,
+    storage.session.getTenant(),
+    ''
+  );
+  return generateOauth2Api(getApiConfig()).post(accessTokenURL, data, config);
+}
+
+/**
+ * Perform client credentials grant flow
+ * @param {String} clientId client id
+ * @param {String} clientSecret client secret
+ * @param {String} scope space-delimited scope list
+ * @returns {Promise} a promise resolving to an object containing the authorization server response object
+ */
+export async function clientCredentialsGrant(clientId, clientSecret, scope) {
+  const urlString = util.format(
+    accessTokenUrlTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath()
+  );
+  const requestOverride = {
+    headers: {
+      Authorization: `Basic ${encode(`${clientId}:${clientSecret}`)}`,
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+  };
+  const requestBody = {
+    grant_type: 'client_credentials',
+    scope,
+  };
+  return generateOauth2Api(getApiConfig(), requestOverride).post(
+    urlString,
+    qs.stringify(requestBody),
+    { withCredentials: true }
+  );
+}

package/src/api/OAuth2ProviderApi.js

@@ -0,0 +1,32 @@
+/* eslint-disable import/prefer-default-export */
+import util from 'util';
+import { generateAmApi } from './BaseApi.js';
+import { getCurrentRealmPath } from './utils/ApiUtils.js';
+import storage from '../storage/SessionStorage.js';
+
+const oauthProviderServiceURLTemplate =
+  '%s/json%s/realm-config/services/oauth-oidc';
+
+const apiVersion = 'protocol=2.1,resource=1.0';
+const getApiConfig = () => {
+  const configPath = getCurrentRealmPath();
+  return {
+    path: `${configPath}/authentication/authenticationtrees`,
+    apiVersion,
+  };
+};
+
+/**
+ * Get OAuth2 Provider
+ * @returns {Promise} a promise that resolves to an object containing an OAuth2Provider object
+ */
+export async function getOAuth2Provider() {
+  const urlString = util.format(
+    oauthProviderServiceURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath()
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}

package/src/api/RealmApi.js

@@ -0,0 +1,99 @@
+import util from 'util';
+import {
+  getTenantURL,
+  getCurrentRealmPath,
+  getRealmName,
+} from './utils/ApiUtils.js';
+import { generateAmApi } from './BaseApi.js';
+import storage from '../storage/SessionStorage.js';
+
+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,
+  };
+};
+
+/**
+ * Get all realms
+ * @returns {Promise} a promise that resolves to an object containing an array of realm objects
+ */
+export async function getRealms() {
+  const urlString = util.format(
+    realmsListURLTemplate,
+    storage.session.getTenant()
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get realm by id
+ * @param {String} id 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,
+    storage.session.getTenant(),
+    id
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get realm by name
+ * @param {String} name realm name
+ * @returns {Promise} a promise that resolves to a realm object
+ */
+export async function getRealmByName(name) {
+  return getRealms().then((realms) => {
+    for (const realm of realms.data.result) {
+      if (getRealmName(name) === realm.name) {
+        return realm;
+      }
+    }
+    throw new Error(`Realm ${name} not found!`);
+  });
+}
+
+/**
+ * Put realm
+ * @param {String} id realm id
+ * @param {Object} data 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,
+    storage.session.getTenant(),
+    id
+  );
+  return generateAmApi(getApiConfig()).put(urlString, data, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Delete realm
+ * @param {String} id 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(storage.session.getTenant()),
+    id
+  );
+  return generateAmApi(getApiConfig()).delete(urlString, {
+    withCredentials: true,
+  });
+}