@rockcarver/frodo-lib 0.11.0

package/src/api/ThemeApi.js

@@ -0,0 +1,181 @@
+import { getConfigEntity, putConfigEntity } from './IdmConfigApi.js';
+import { getCurrentRealmName } from './utils/ApiUtils.js';
+
+const THEMEREALM_ID = 'ui/themerealm';
+
+/**
+ * Get realm themes
+ * @param {Object} themes object containing themes
+ * @returns {Object} array of theme pertaining to the current realm
+ */
+function getRealmThemes(themes) {
+  return themes.realm[getCurrentRealmName()]
+    ? themes.realm[getCurrentRealmName()]
+    : [];
+}
+
+/**
+ * Get all themes
+ * @returns {Promise} a promise that resolves to an array of themes
+ */
+export async function getThemes() {
+  return getConfigEntity(THEMEREALM_ID).then((response) =>
+    getRealmThemes(response.data)
+  );
+}
+
+/**
+ * Get theme by id
+ * @param {String} id theme id
+ * @returns {Promise} a promise that resolves to an array of themes
+ */
+export async function getTheme(id) {
+  const themes = (await getConfigEntity(THEMEREALM_ID)).data;
+  return getRealmThemes(themes).filter((theme) => theme._id === id);
+}
+
+/**
+ * Get theme by name
+ * @param {String} name theme name
+ * @returns {Promise} a promise that resolves to an array of themes
+ */
+export async function getThemeByName(name) {
+  const themes = (await getConfigEntity(THEMEREALM_ID)).data;
+  return getRealmThemes(themes).filter((theme) => theme.name === name);
+}
+
+/**
+ * Put theme by id
+ * @param {String} id theme id
+ * @param {Object} data theme object
+ * @returns {Promise} a promise that resolves to an object containing a themes object
+ */
+export async function putTheme(id, data) {
+  const themeData = data;
+  themeData._id = id;
+  const themes = (await getConfigEntity(THEMEREALM_ID)).data;
+  let isNew = true;
+  const realmThemes = getRealmThemes(themes).map((theme) => {
+    if (theme._id === id) {
+      isNew = false;
+      return themeData;
+    }
+    // eslint-disable-next-line no-param-reassign
+    if (themeData.isDefault) theme.isDefault = false;
+    return theme;
+  });
+  if (isNew) {
+    realmThemes.push(themeData);
+  }
+  themes.realm[getCurrentRealmName()] = realmThemes;
+  return putConfigEntity(THEMEREALM_ID, themes);
+}
+
+/**
+ * Put theme by name
+ * @param {String} name theme name
+ * @param {Object} data theme object
+ * @returns {Promise} a promise that resolves to an object containing a themes object
+ */
+export async function putThemeByName(name, data) {
+  const themeData = data;
+  themeData.name = name;
+  const themes = await getConfigEntity(THEMEREALM_ID);
+  let isNew = true;
+  const realmThemes = getRealmThemes(themes).map((theme) => {
+    if (theme.name === name) {
+      isNew = false;
+      return themeData;
+    }
+    // eslint-disable-next-line no-param-reassign
+    if (themeData.isDefault) theme.isDefault = false;
+    return theme;
+  });
+  if (isNew) {
+    realmThemes.push(themeData);
+  }
+  themes.realm[getCurrentRealmName()] = realmThemes;
+  return putConfigEntity(THEMEREALM_ID, themes);
+}
+
+/**
+ * Put all themes
+ * @param {Object} data themes object containing all themes for all realms
+ * @returns {Promise} a promise that resolves to an object containing a themes object
+ */
+export async function putThemes(data) {
+  const allThemesData = data;
+  const themes = (await getConfigEntity(THEMEREALM_ID)).data;
+  const allThemeIDs = Object.keys(allThemesData);
+  const existingThemeIDs = [];
+  let defaultThemeId = null;
+  // update existing themes
+  let realmThemes = getRealmThemes(themes).map((theme) => {
+    if (allThemesData[theme._id]) {
+      existingThemeIDs.push(theme._id);
+      // remember the id of the last default theme
+      if (allThemesData[theme._id].isDefault) defaultThemeId = theme._id;
+      return allThemesData[theme._id];
+    }
+    return theme;
+  });
+  const newThemeIDs = allThemeIDs.filter(
+    (id) => !existingThemeIDs.includes(id)
+  );
+  // add new themes
+  newThemeIDs.forEach((themeId) => {
+    // remember the id of the last default theme
+    if (allThemesData[themeId].isDefault) defaultThemeId = themeId;
+    realmThemes.push(allThemesData[themeId]);
+  });
+  // if we imported a default theme, flag all the other themes as not default
+  if (defaultThemeId) {
+    realmThemes = realmThemes.map((theme) => {
+      // eslint-disable-next-line no-param-reassign
+      theme.isDefault = theme._id === defaultThemeId;
+      return theme;
+    });
+  }
+  themes.realm[getCurrentRealmName()] = realmThemes;
+  return putConfigEntity(THEMEREALM_ID, themes);
+}
+
+/**
+ * Delete theme by id
+ * @param {String} id theme id
+ * @returns {Promise} a promise that resolves to an object containing a themes object
+ */
+export async function deleteTheme(id) {
+  const themes = (await getConfigEntity(THEMEREALM_ID)).data;
+  const realmThemes = getRealmThemes(themes);
+  const finalThemes = realmThemes.filter((theme) => theme._id !== id);
+  if (realmThemes.length === finalThemes.length)
+    throw new Error(`${id} not found`);
+  themes.realm[getCurrentRealmName()] = realmThemes;
+  return putConfigEntity(THEMEREALM_ID, themes);
+}
+
+/**
+ * Delete theme by name
+ * @param {String} name theme name
+ * @returns {Promise} a promise that resolves to an object containing a themes object
+ */
+export async function deleteThemeByName(name) {
+  const themes = (await getConfigEntity(THEMEREALM_ID)).data;
+  const realmThemes = getRealmThemes(themes);
+  const finalThemes = realmThemes.filter((theme) => theme.name !== name);
+  if (realmThemes.length === finalThemes.length)
+    throw new Error(`${name} not found`);
+  themes.realm[getCurrentRealmName()] = finalThemes;
+  return putConfigEntity(THEMEREALM_ID, themes);
+}
+
+/**
+ * Delete all themes
+ * @returns {Promise} a promise that resolves to an array of themes
+ */
+export async function deleteThemes() {
+  const themes = (await getConfigEntity(THEMEREALM_ID)).data;
+  themes.realm[getCurrentRealmName()] = [];
+  return putConfigEntity(THEMEREALM_ID, themes);
+}

package/src/api/TreeApi.js

@@ -0,0 +1,207 @@
+import util from 'util';
+import { deleteDeepByKey, getCurrentRealmPath } from './utils/ApiUtils.js';
+import { generateAmApi } from './BaseApi.js';
+import storage from '../storage/SessionStorage.js';
+
+const nodeURLTemplate =
+  '%s/json%s/realm-config/authentication/authenticationtrees/nodes/%s/%s';
+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 queryAllNodeTypesURLTemplate =
+  '%s/json%s/realm-config/authentication/authenticationtrees/nodes?_action=getAllTypes';
+const treeByIdURLTemplate =
+  '%s/json%s/realm-config/authentication/authenticationtrees/trees/%s';
+const queryAllTreesURLTemplate =
+  '%s/json%s/realm-config/authentication/authenticationtrees/trees?_queryFilter=true';
+
+const apiVersion = 'protocol=2.1,resource=1.0';
+const getTreeApiConfig = () => {
+  const configPath = getCurrentRealmPath();
+  return {
+    path: `${configPath}/authentication/authenticationtrees`,
+    apiVersion,
+  };
+};
+
+export async function getNodeTypes() {
+  const urlString = util.format(
+    queryAllNodeTypesURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath()
+  );
+  return generateAmApi(getTreeApiConfig()).post(
+    urlString,
+    {},
+    {
+      withCredentials: true,
+      headers: { 'Accept-Encoding': 'gzip, deflate, br' },
+    }
+  );
+}
+
+/**
+ * Get all nodes
+ * @returns {Promise} a promise that resolves to an object containing an array of all node objects
+ */
+export async function getNodes() {
+  const urlString = util.format(
+    queryAllNodesURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath()
+  );
+  return generateAmApi(getTreeApiConfig()).post(
+    urlString,
+    {},
+    {
+      withCredentials: true,
+      headers: { 'Accept-Encoding': 'gzip, deflate, br' },
+    }
+  );
+}
+
+/**
+ * Get all nodes by type
+ * @param {*} type 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(type) {
+  const urlString = util.format(
+    queryAllNodesByTypeURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    type
+  );
+  return generateAmApi(getTreeApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get node by uuid and type
+ * @param {String} id node uuid
+ * @param {String} nodeType node type
+ * @returns {Promise} a promise that resolves to an object containing a node object
+ */
+export async function getNode(id, nodeType) {
+  const urlString = util.format(
+    nodeURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(storage.session.getRealm()),
+    nodeType,
+    id
+  );
+  return generateAmApi(getTreeApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Put node by uuid and type
+ * @param {String} id node uuid
+ * @param {String} nodeType node type
+ * @param {Object} data node object
+ * @returns {Promise} a promise that resolves to an object containing a node object
+ */
+export async function putNode(id, nodeType, nodeData) {
+  // until we figure out a way to use transport keys in Frodo,
+  // we'll have to drop those encrypted attributes.
+  const data = deleteDeepByKey(nodeData, '-encrypted');
+  const urlString = util.format(
+    nodeURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(storage.session.getRealm()),
+    nodeType,
+    id
+  );
+  return generateAmApi(getTreeApiConfig()).put(urlString, data, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Delete node by uuid and type
+ * @param {String} id node uuid
+ * @param {String} nodeType node type
+ * @returns {Promise} a promise that resolves to an object containing a node object
+ */
+export async function deleteNode(id, nodeType) {
+  const urlString = util.format(
+    nodeURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    nodeType,
+    id
+  );
+  return generateAmApi(getTreeApiConfig()).delete(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get all trees
+ * @returns {Promise} a promise that resolves to an object containing an array of tree objects
+ */
+export async function getTrees() {
+  const urlString = util.format(
+    queryAllTreesURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath()
+  );
+  return generateAmApi(getTreeApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get tree by id/name
+ * @param {String} id tree id/name
+ * @returns {Promise} a promise that resolves to an object containing a tree object
+ */
+export async function getTree(id) {
+  const urlString = util.format(
+    treeByIdURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    id
+  );
+  return generateAmApi(getTreeApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Put tree by id/name
+ * @param {String} id tree id/name
+ * @param {Object} data tree object
+ * @returns {Promise} a promise that resolves to an object containing a tree object
+ */
+export async function putTree(id, data) {
+  const urlString = util.format(
+    treeByIdURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(storage.session.getRealm()),
+    id
+  );
+  return generateAmApi(getTreeApiConfig()).put(urlString, data, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Delete tree by id/name
+ * @param {String} id tree id/name
+ * @returns {Promise} a promise that resolves to an object containing a tree object
+ */
+export async function deleteTree(id) {
+  const urlString = util.format(
+    treeByIdURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    id
+  );
+  return generateAmApi(getTreeApiConfig()).delete(urlString, {
+    withCredentials: true,
+  });
+}

package/src/api/VariablesApi.js

@@ -0,0 +1,104 @@
+import util from 'util';
+import { encode } from './utils/Base64.js';
+import { getTenantURL, getCurrentRealmPath } from './utils/ApiUtils.js';
+import { generateESVApi } from './BaseApi.js';
+import storage from '../storage/SessionStorage.js';
+
+const variablesListURLTemplate = '%s/environment/variables';
+const variableURLTemplate = '%s/environment/variables/%s';
+const variableSetDescriptionURLTemplate = `${variableURLTemplate}?_action=setDescription`;
+
+const apiVersion = 'protocol=1.0,resource=1.0';
+const getApiConfig = () => {
+  const configPath = getCurrentRealmPath();
+  return {
+    path: `${configPath}/environment/secrets`,
+    apiVersion,
+  };
+};
+
+/**
+ * Get all variables
+ * @returns {Promise} a promise that resolves to an object containing an array of variable objects
+ */
+export async function getVariables() {
+  const urlString = util.format(
+    variablesListURLTemplate,
+    getTenantURL(storage.session.getTenant())
+  );
+  return generateESVApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get variable by id/name
+ * @param {String} id variable id/name
+ * @returns {Promise} a promise that resolves to an object containing a variable object
+ */
+export async function getVariable(id) {
+  const urlString = util.format(
+    variableURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id
+  );
+  return generateESVApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Put variable by id/name
+ * @param {String} id variable id/name
+ * @param {String} value variable value
+ * @param {String} description variable description
+ * @returns {Promise} a promise that resolves to an object containing a variable object
+ */
+export async function putVariable(id, value, description) {
+  const data = {};
+  if (value) data.valueBase64 = encode(value);
+  if (description) data.description = description;
+  const urlString = util.format(
+    variableURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id
+  );
+  return generateESVApi(getApiConfig()).put(urlString, data, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Set variable description
+ * @param {*} id variable id/name
+ * @param {*} description variable description
+ * @returns {Promise} a promise that resolves to an object containing a status object
+ */
+export async function setVariableDescription(id, description) {
+  const urlString = util.format(
+    variableSetDescriptionURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id
+  );
+  return generateESVApi(getApiConfig()).post(
+    urlString,
+    { description },
+    { withCredentials: true }
+  );
+}
+
+/**
+ * Delete variable by id/name
+ * @param {String} id variable id/name
+ * @returns {Promise} a promise that resolves to an object containing a variable object
+ */
+export async function deleteVariable(id) {
+  const urlString = util.format(
+    variableURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id
+  );
+  return generateESVApi(getApiConfig()).delete(urlString, {
+    withCredentials: true,
+  });
+}

package/src/api/utils/ApiUtils.js

@@ -0,0 +1,77 @@
+import util from 'util';
+import storage from '../../storage/SessionStorage.js';
+
+const realmPathTemplate = '/realms/%s';
+
+/**
+ * Get current realm path
+ * @returns {String} a CREST-compliant realm path, e.g. /realms/root/realms/alpha
+ */
+export function getCurrentRealmPath() {
+  let realm = storage.session.getRealm();
+  if (realm.startsWith('/') && realm.length > 1) {
+    realm = realm.substring(1);
+  }
+  let realmPath = util.format(realmPathTemplate, 'root');
+  if (realm !== '/') {
+    realmPath += util.format(realmPathTemplate, realm);
+  }
+  return realmPath;
+}
+
+/**
+ * Get current realm name
+ * @returns {String} name of the current realm. /alpha -> alpha
+ */
+export function getCurrentRealmName() {
+  const realm = storage.session.getRealm();
+  const components = realm.split('/');
+  let realmName = '/';
+  if (components.length > 0 && realmName !== realm) {
+    realmName = components[components.length - 1];
+  }
+  return realmName;
+}
+
+/**
+ * Get current realm name
+ * @param {String} realm realm
+ * @returns {String} name of the realm. /alpha -> alpha
+ */
+export function getRealmName(realm) {
+  const components = realm.split('/');
+  let realmName = '/';
+  if (components.length > 0 && realmName !== realm) {
+    realmName = components[components.length - 1];
+  }
+  return realmName;
+}
+
+/**
+ * Get tenant base URL
+ * @param {String} tenant tenant URL with path and query params
+ * @returns {String} tenant base URL without path and query params
+ */
+export function getTenantURL(tenant) {
+  const parsedUrl = new URL(tenant);
+  return `${parsedUrl.protocol}//${parsedUrl.host}`;
+}
+
+/**
+ * Deep delete keys and their values from an input object. If a key in object contains substring, the key an its value is deleted.
+ * @param {Object} object input object that needs keys removed
+ * @param {String} substring substring to search for in key
+ * @returns the modified object without the matching keys and their values
+ */
+export function deleteDeepByKey(object, substring) {
+  const obj = object;
+  const keys = Object.keys(obj);
+  for (const key of keys) {
+    if (key.indexOf(substring) > 0) {
+      delete obj[key];
+    } else if (Object(obj[key]) === obj[key]) {
+      obj[key] = deleteDeepByKey(obj[key], substring);
+    }
+  }
+  return obj;
+}

package/src/api/utils/ApiUtils.test.js

@@ -0,0 +1,96 @@
+import {
+  getCurrentRealmPath,
+  getTenantURL,
+} from './ApiUtils.js';
+import sessionStorage from '../../storage/SessionStorage.js';
+
+test.skip('replaceAll should be deleted because it works like native String.replaceAll', () => {
+  // Arrange
+  // Act
+  // Assert
+  expect(true).toBe(false);
+});
+
+test('getCurrentRealmPath should prepend realmPath to specified realm', () => {
+  // Arrange
+  const REALM_PATH = 'alpha';
+  sessionStorage.session.setItem('realm', REALM_PATH);
+  // Act
+  const testString = getCurrentRealmPath(REALM_PATH);
+  // Assert
+  expect(testString).toBe('/realms/root/realms/alpha');
+});
+
+test('getCurrentRealmPath should prepend realmPath to specified realm with leading slash', () => {
+  // Arrange
+  const REALM_PATH = '/alpha';
+  sessionStorage.session.setItem('realm', REALM_PATH);
+  // Act
+  const testString = getCurrentRealmPath(REALM_PATH);
+  // Assert
+  expect(testString).toBe('/realms/root/realms/alpha');
+});
+
+test('getCurrentRealmPath "/" should resolve to root', () => {
+  // Arrange
+  const REALM_PATH = '/';
+  sessionStorage.session.setItem('realm', REALM_PATH);
+  // Act
+  const testString = getCurrentRealmPath(REALM_PATH);
+  // Assert
+  expect(testString).toBe('/realms/root');
+});
+
+test('getCurrentRealmPath should not handle multiple leading slash', () => {
+  // Arrange
+  const REALM_PATH = '//alpha';
+  sessionStorage.session.setItem('realm', REALM_PATH);
+  // Act
+  const testString = getCurrentRealmPath(REALM_PATH);
+  // Assert
+  expect(testString).toBe('/realms/root/realms//alpha');
+});
+
+test('getCurrentRealmPath should not handle nested depth realms', () => {
+  // Arrange
+  const REALM_PATH = '/alpha/erm';
+  sessionStorage.session.setItem('realm', REALM_PATH);
+  // Act
+  const testString = getCurrentRealmPath(REALM_PATH);
+  // Assert
+  expect(testString).toBe('/realms/root/realms/alpha/erm');
+});
+
+test('getTenantURL should parse the https protocol and the hostname', () => {
+  // Arrange
+  const URL_WITH_TENANT =
+    'https://example.frodo.com/am/ui-admin/#realms/%2Falpha/dashboard';
+
+  // Act
+  const parsed = getTenantURL(URL_WITH_TENANT);
+
+  // Assert
+  expect(parsed).toBe('https://example.frodo.com');
+});
+
+test('getTenantURL should not validate protocol', () => {
+  // Arrange
+  const URL_WITH_TENANT =
+    'ftp://example.frodo.com/am/ui-admin/#realms/%2Falpha/dashboard';
+  // Act
+  const parsed = getTenantURL(URL_WITH_TENANT);
+  // Assert
+  expect(parsed).toBe('ftp://example.frodo.com');
+});
+
+test('getTenantURL Invalid URL should throw', () => {
+  // Arrange
+  const URL_WITH_TENANT =
+    '//:example.frodo.com/am/ui-admin/#realms/%2Falpha/dashboard';
+  // Act
+  const trap = () => {
+    getTenantURL(URL_WITH_TENANT);
+  };
+  // Assert
+  expect(trap).toThrow('Invalid URL');
+});