@rockcarver/frodo-lib 0.11.0

package/src/api/Saml2Api.js

@@ -0,0 +1,176 @@
+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 providerByLocationAndIdURLTemplate = '%s/json%s/realm-config/saml2/%s/%s';
+const createHostedProviderURLTemplate =
+  '%s/json%s/realm-config/saml2/hosted/?_action=create';
+const createRemoteProviderURLTemplate =
+  '%s/json%s/realm-config/saml2/remote/?_action=importEntity';
+const queryAllProvidersURLTemplate =
+  '%s/json%s/realm-config/saml2?_queryFilter=true';
+const queryProvidersByEntityIdURLTemplate =
+  '%s/json%s/realm-config/saml2?_queryFilter=%s&_fields=%s';
+const metadataByEntityIdURLTemplate =
+  '%s/saml2/jsp/exportmetadata.jsp?entityid=%s&realm=%s';
+const apiVersion = 'protocol=2.1,resource=1.0';
+const getApiConfig = () => {
+  const configPath = getCurrentRealmPath();
+  return {
+    path: `${configPath}/realm-config/saml2`,
+    apiVersion,
+  };
+};
+
+/**
+ * Get all SAML2 entity providers
+ * @returns {Promise} a promise that resolves to an array of saml2 entity stubs
+ */
+export async function getProviders() {
+  const urlString = util.format(
+    queryAllProvidersURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath()
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Find all providers matching the filter and return the requested fields
+ * @param {String} filter CREST filter string, eg "entityId+eq+'${entityId}'"
+ * @param {String} fields Comma-delimited list of fields to include in the response
+ * @returns {Promise} a promise that resolves to an array of saml2 entities
+ */
+export async function findProviders(filter = 'true', fields = '*') {
+  const urlString = util.format(
+    queryProvidersByEntityIdURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    encodeURIComponent(filter),
+    fields
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Geta SAML2 entity provider by location and id
+ * @param {String} location Entity provider location (hosted or remote)
+ * @param {String} entityId64 Base64-encoded provider entity id
+ * @returns {Promise} a promise that resolves to a saml2 entity provider object
+ */
+export async function getProviderByLocationAndId(location, entityId64) {
+  const urlString = util.format(
+    providerByLocationAndIdURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    location,
+    entityId64
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get SAML2 entity provider by entity id
+ * @param {String} entityId Provider entity id
+ * @returns {Promise} a promise that resolves to a saml2 entity provider object or null
+ */
+export async function getProvider(entityId) {
+  const response = await findProviders(`entityId eq '${entityId}'`, 'location');
+  switch (response.data.resultCount) {
+    case 0:
+      throw new Error(`No provider with entity id '${entityId}' found`);
+    case 1: {
+      const { location } = response.data.result[0];
+      const id = response.data.result[0]._id;
+      return getProviderByLocationAndId(location, id);
+    }
+    default:
+      throw new Error(`Multiple providers with entity id '${entityId}' found`);
+  }
+}
+
+/**
+ * Get a SAML2 entity provider's metadata URL by entity id
+ * @param {String} entityId SAML2 entity id
+ * @returns {String} the URL to get the metadata from
+ */
+export function getProviderMetadataUrl(entityId) {
+  return util.format(
+    metadataByEntityIdURLTemplate,
+    storage.session.getTenant(),
+    encodeURIComponent(entityId),
+    storage.session.getRealm()
+  );
+}
+
+/**
+ * Get a SAML2 entity provider's metadata by entity id
+ * @param {String} entityId SAML2 entity id
+ * @returns {Promise} a promise that resolves to an object containing a SAML2 metadata
+ */
+export async function getProviderMetadata(entityId) {
+  return generateAmApi(getApiConfig()).get(getProviderMetadataUrl(entityId), {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Create a SAML2 entity provider
+ * @param {String} location 'hosted' or 'remote'
+ * @param {Object} providerData Object representing a SAML entity provider
+ * @param {String} metaData Base64-encoded metadata XML. Only required for remote providers
+ * @returns {Promise} a promise that resolves to a saml2 entity provider object
+ */
+export async function createProvider(location, providerData, metaData) {
+  let postData = _.cloneDeep(providerData);
+  let urlString = util.format(
+    createHostedProviderURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(storage.session.getRealm())
+  );
+
+  if (location === 'remote') {
+    /**
+     * Remote entity providers must be created using XML metadata
+     */
+    urlString = util.format(
+      createRemoteProviderURLTemplate,
+      storage.session.getTenant(),
+      getCurrentRealmPath(storage.session.getRealm())
+    );
+    postData = {
+      standardMetadata: metaData,
+    };
+  }
+
+  return generateAmApi(getApiConfig()).post(urlString, postData, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Update SAML2 entity provider
+ * @param {String} location Entity provider location (hosted or remote)
+ * @param {Object} providerData Object representing a SAML entity provider
+ * @returns {Promise} a promise that resolves to a saml2 entity provider object
+ */
+export async function updateProvider(location, providerData) {
+  const urlString = util.format(
+    providerByLocationAndIdURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    location,
+    providerData._id
+  );
+  return generateAmApi(getApiConfig()).put(urlString, providerData, {
+    withCredentials: true,
+  });
+}

package/src/api/ScriptApi.js

@@ -0,0 +1,84 @@
+import util from 'util';
+import { generateAmApi } from './BaseApi.js';
+import { getCurrentRealmPath } from './utils/ApiUtils.js';
+import storage from '../storage/SessionStorage.js';
+
+const scriptURLTemplate = '%s/json%s/scripts/%s';
+const scriptListURLTemplate = '%s/json%s/scripts?_queryFilter=true';
+const scriptQueryURLTemplate =
+  '%s/json%s/scripts?_queryFilter=name+eq+%%22%s%%22';
+const apiVersion = 'protocol=2.0,resource=1.0';
+const getApiConfig = () => {
+  const configPath = getCurrentRealmPath();
+  return {
+    path: `${configPath}/authentication/authenticationtrees`,
+    apiVersion,
+  };
+};
+
+/**
+ * Get all scripts
+ * @returns {Promise} a promise that resolves to an object containing an array of script objects
+ */
+export async function getScripts() {
+  const urlString = util.format(
+    scriptListURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath()
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get script by name
+ * @param {String} name script name
+ * @returns {Promise} a promise that resolves to an object containing a script object
+ */
+export async function getScriptByName(name) {
+  const urlString = util.format(
+    scriptQueryURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    name
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get script by id
+ * @param {String} id script uuid/name
+ * @returns {Promise} a promise that resolves to an object containing a script object
+ */
+export async function getScript(id) {
+  const urlString = util.format(
+    scriptURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    id
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Put script
+ * @param {String} id script uuid
+ * @param {Object} data script object
+ * @returns {Promise} a promise that resolves to an object containing a script object
+ */
+export async function putScript(id, data) {
+  const urlString = util.format(
+    scriptURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(storage.session.getRealm()),
+    id
+  );
+  return generateAmApi(getApiConfig()).put(urlString, data, {
+    withCredentials: true,
+  });
+}

package/src/api/SecretsApi.js

@@ -0,0 +1,151 @@
+import util from 'util';
+import { encode } from './utils/Base64.js';
+import { getTenantURL } from './utils/ApiUtils.js';
+import { generateESVApi } from './BaseApi.js';
+import storage from '../storage/SessionStorage.js';
+
+const secretsListURLTemplate = '%s/environment/secrets';
+const secretListVersionsURLTemplate = '%s/environment/secrets/%s/versions';
+const secretCreateNewVersionURLTemplate = `${secretListVersionsURLTemplate}?_action=create`;
+const secretGetVersionURLTemplate = `${secretListVersionsURLTemplate}/%s`;
+const secretVersionStatusURLTemplate = `${secretGetVersionURLTemplate}?_action=changestatus`;
+const secretURLTemplate = '%s/environment/secrets/%s';
+const secretSetDescriptionURLTemplate = `${secretURLTemplate}?_action=setDescription`;
+
+const apiVersion = 'protocol=1.0,resource=1.0';
+const getApiConfig = () => ({
+  path: `/environment/secrets`,
+  apiVersion,
+});
+
+export async function getSecrets() {
+  const urlString = util.format(
+    secretsListURLTemplate,
+    getTenantURL(storage.session.getTenant())
+  );
+  return generateESVApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+export async function getSecret(id) {
+  const urlString = util.format(
+    secretURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id
+  );
+  return generateESVApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+export async function putSecret(
+  id,
+  value,
+  description,
+  encoding = 'generic',
+  useInPlaceholders = true
+) {
+  if (encoding !== 'generic')
+    throw new Error(`Unsupported encoding: ${encoding}`);
+  const data = {
+    valueBase64: encode(value),
+    description,
+    encoding,
+    useInPlaceholders,
+  };
+  const urlString = util.format(
+    secretURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id
+  );
+  return generateESVApi(getApiConfig()).put(urlString, data, {
+    withCredentials: true,
+  });
+}
+
+export async function setSecretDescription(id, description) {
+  const urlString = util.format(
+    secretSetDescriptionURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id
+  );
+  return generateESVApi(getApiConfig()).post(
+    urlString,
+    { description },
+    { withCredentials: true }
+  );
+}
+
+export async function deleteSecret(id) {
+  const urlString = util.format(
+    secretURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id
+  );
+  return generateESVApi(getApiConfig()).delete(urlString, {
+    withCredentials: true,
+  });
+}
+
+export async function getSecretVersions(id) {
+  const urlString = util.format(
+    secretListVersionsURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id
+  );
+  return generateESVApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+export async function createNewVersionOfSecret(id, value) {
+  const urlString = util.format(
+    secretCreateNewVersionURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id
+  );
+  return generateESVApi(getApiConfig()).post(
+    urlString,
+    { valueBase64: encode(value) },
+    { withCredentials: true }
+  );
+}
+
+export async function getVersionOfSecret(id, version) {
+  const urlString = util.format(
+    secretGetVersionURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id,
+    version
+  );
+  return generateESVApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+export async function setStatusOfVersionOfSecret(id, version, status) {
+  const urlString = util.format(
+    secretVersionStatusURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id,
+    version
+  );
+  return generateESVApi(getApiConfig()).post(
+    urlString,
+    { status },
+    { withCredentials: true }
+  );
+}
+
+export async function deleteVersionOfSecret(id, version) {
+  const urlString = util.format(
+    secretGetVersionURLTemplate,
+    getTenantURL(storage.session.getTenant()),
+    id,
+    version
+  );
+  return generateESVApi(getApiConfig()).delete(urlString, {
+    withCredentials: true,
+  });
+}

package/src/api/ServerInfoApi.js

@@ -0,0 +1,41 @@
+import util from 'util';
+import { generateAmApi } from './BaseApi.js';
+import storage from '../storage/SessionStorage.js';
+
+const serverInfoUrlTemplate = '%s/json/serverinfo/%s';
+
+const serverInfoApiVersion = 'resource=1.1';
+const getServerInfoApiConfig = () => ({
+  apiVersion: serverInfoApiVersion,
+});
+
+const serverVersionoApiVersion = 'resource=1.0';
+const getServerVersionApiConfig = () => ({
+  apiVersion: serverVersionoApiVersion,
+});
+
+/**
+ * Get server info
+ * @returns {Promise} a promise that resolves to an object containing a server info object
+ */
+export async function getServerInfo() {
+  const urlString = util.format(
+    serverInfoUrlTemplate,
+    storage.session.getTenant(),
+    '*'
+  );
+  return generateAmApi(getServerInfoApiConfig()).get(urlString, {});
+}
+
+/**
+ * Get server version info
+ * @returns {Promise} a promise that resolves to an object containing a server version info object
+ */
+export async function getServerVersionInfo() {
+  const urlString = util.format(
+    serverInfoUrlTemplate,
+    storage.session.getTenant(),
+    'version'
+  );
+  return generateAmApi(getServerVersionApiConfig()).get(urlString, {});
+}

package/src/api/SocialIdentityProvidersApi.js

@@ -0,0 +1,114 @@
+import util from 'util';
+import { generateAmApi } from './BaseApi.js';
+import { deleteDeepByKey, getCurrentRealmPath } from './utils/ApiUtils.js';
+import storage from '../storage/SessionStorage.js';
+
+const getAllProviderTypesURLTemplate =
+  '%s/json%s/realm-config/services/SocialIdentityProviders?_action=getAllTypes';
+const providerByTypeAndIdURLTemplate =
+  '%s/json%s/realm-config/services/SocialIdentityProviders/%s/%s';
+const getAllProvidersURLTemplate =
+  '%s/json%s/realm-config/services/SocialIdentityProviders?_action=nextdescendents';
+const getProvidersByTypeURLTemplate =
+  '%s/json%s/realm-config/services/SocialIdentityProviders/%s?_queryFilter=true';
+const apiVersion = 'protocol=2.1,resource=1.0';
+const getApiConfig = () => {
+  const configPath = getCurrentRealmPath();
+  return {
+    path: `${configPath}/realm-config/services/SocialIdentityProviders`,
+    apiVersion,
+  };
+};
+
+/**
+ * Get social identity provider types
+ * @returns {Promise} a promise that resolves to an object containing an array of social identity provider types
+ */
+export async function getSocialIdentityProviderTypes() {
+  const urlString = util.format(
+    getAllProviderTypesURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath()
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get social identity providers by type
+ * @param {String} type social identity provider type
+ * @returns {Promise} a promise that resolves to an object containing an array of social identity providers of the requested type
+ */
+export async function getSocialIdentityProvidersByType(type) {
+  const urlString = util.format(
+    getProvidersByTypeURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    type
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get all social identity providers
+ * @returns {Promise} a promise that resolves to an object containing an array of social identity providers
+ */
+export async function getSocialIdentityProviders() {
+  const urlString = util.format(
+    getAllProvidersURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath()
+  );
+  return generateAmApi(getApiConfig()).post(
+    urlString,
+    {},
+    {
+      withCredentials: true,
+    }
+  );
+}
+
+/**
+ * Get social identity provider by type and id
+ * @param {*} type social identity provider type
+ * @param {*} id social identity provider id/name
+ * @returns {Promise} a promise that resolves to an object containing a social identity provider
+ */
+export async function getProviderByTypeAndId(type, id) {
+  const urlString = util.format(
+    providerByTypeAndIdURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(),
+    type,
+    id
+  );
+  return generateAmApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Get social identity provider by type and id
+ * @param {String} type social identity provider type
+ * @param {String} id social identity provider id/name
+ * @param {Object} data a social identity provider object
+ * @returns {Promise} a promise that resolves to an object containing a social identity provider
+ */
+export async function putProviderByTypeAndId(type, id, data) {
+  // until we figure out a way to use transport keys in Frodo,
+  // we'll have to drop those encrypted attributes.
+  const providerData = deleteDeepByKey(data, '-encrypted');
+  const urlString = util.format(
+    providerByTypeAndIdURLTemplate,
+    storage.session.getTenant(),
+    getCurrentRealmPath(storage.session.getRealm()),
+    type,
+    id
+  );
+  return generateAmApi(getApiConfig()).put(urlString, providerData, {
+    withCredentials: true,
+  });
+}

package/src/api/StartupApi.js

@@ -0,0 +1,45 @@
+import util from 'util';
+import { getTenantURL } from './utils/ApiUtils.js';
+import { generateESVApi } from './BaseApi.js';
+import storage from '../storage/SessionStorage.js';
+
+const startupURLTemplate = '%s/environment/startup';
+const startupInitiateRestartURLTemplate = `${startupURLTemplate}?_action=restart`;
+
+const apiVersion = 'protocol=1.0,resource=1.0';
+const getApiConfig = () => ({
+  path: `/environment/startup`,
+  apiVersion,
+});
+
+/**
+ * Get status
+ * @returns {Promise} a promise that resolves to a status object
+ */
+export async function getStatus() {
+  const urlString = util.format(
+    startupURLTemplate,
+    getTenantURL(storage.session.getTenant())
+  );
+  return generateESVApi(getApiConfig()).get(urlString, {
+    withCredentials: true,
+  });
+}
+
+/**
+ * Initiate restart
+ * @returns {Promise} a promise that resolves to a status object
+ */
+export async function initiateRestart() {
+  const { restartStatus } = (await getStatus()).data;
+  if (restartStatus === 'ready') {
+    const urlString = util.format(
+      startupInitiateRestartURLTemplate,
+      getTenantURL(storage.session.getTenant())
+    );
+    return generateESVApi(getApiConfig()).post(urlString, null, {
+      withCredentials: true,
+    });
+  }
+  throw new Error(`Not ready! Current status: ${restartStatus}`);
+}