Changes for fr-config-manager commands

src/api/IdmConfigApi.ts

@@ -60,17 +60,20 @@ export async function getConfigEntities({
 /**
  * Get IDM config entities by type
  * @param {string} type the desired type of config entity
+ * @param {boolean} includeDefault Include default email templates if true, false to exclude them. Default: false
  * @returns {Promise} a promise that resolves to an object containing all IDM config entities of the desired type
  */
 export async function getConfigEntitiesByType({
   type,
+  includeDefault = false,
   state,
 }: {
   type: string;
+  includeDefault?: boolean;
   state: State;
 }): Promise<PagedResult<NoIdObjectSkeletonInterface>> {
-  // Due to a bug (as of Ping IDM 7.5.0) with the query filter for email templates (it happens using both sw or co), in order to get all the email templates you need to use 'emailTemplat' instead.
-  if (type === EMAIL_TEMPLATE_TYPE) {
+  // Due to a bug (as of Ping IDM 7.5.0) with the query filter for email templates (it happens using both sw or co), in order to get all the email templates, including default, you need to use 'emailTemplat' instead.
+  if (type === EMAIL_TEMPLATE_TYPE && includeDefault) {
     type = EMAIL_TEMPLATE_TYPE.substring(0, EMAIL_TEMPLATE_TYPE.length - 1);
   }
   const urlString = util.format(

src/api/RawApi.ts

@@ -0,0 +1,62 @@
+import util from 'util';
+
+import { State } from '../shared/State';
+import { getIdmBaseUrl } from '../utils/ForgeRockUtils';
+import { generateAmApi, generateEnvApi, generateIdmApi } from './BaseApi';
+
+const idmTemplate: string = '%s/%s';
+const amTemplate: string = '%s/%s';
+const envTemplate: string = '%s/environment/%s';
+
+export async function restGetRawIdm({
+  state,
+  url,
+}: {
+  state: State;
+  url: string;
+}) {
+  const urlString = util.format(idmTemplate, getIdmBaseUrl(state), url);
+  const { data } = await generateIdmApi({ state }).get(urlString);
+
+  return data;
+}
+
+export async function restGetRawAm({
+  state,
+  url,
+}: {
+  state: State;
+  url: string;
+}) {
+  const urlString = util.format(amTemplate, state.getHost(), url);
+  const { data } = await generateAmApi({
+    resource: { apiVersion: 'protocol=2.1,resource=1.0' },
+    state,
+  }).get(urlString, { withCredentials: true });
+
+  return data;
+}
+
+export async function restGetRawEnv({
+  state,
+  url,
+}: {
+  state: State;
+  url: string;
+}) {
+  const urlString = util.format(
+    envTemplate,
+    state
+      .getHost()
+      .split('/')
+      .filter((_, i, a) => i !== a.length - 1)
+      .join('/'),
+    url
+  );
+  const { data } = await generateEnvApi({
+    resource: { apiVersion: 'protocol=2.1,resource=1.0' },
+    state,
+  }).get(urlString, { withCredentials: true });
+
+  return data;
+}

src/lib/FrodoLib.ts

@@ -75,6 +75,7 @@ import OAuth2TrustedJwtIssuerOps, {
 import OrganizationOps, { Organization } from '../ops/OrganizationOps';
 import PolicyOps, { Policy } from '../ops/PolicyOps';
 import PolicySetOps, { PolicySet } from '../ops/PolicySetOps';
+import RawOps, { Raw } from '../ops/RawOps';
 import RealmOps, { Realm } from '../ops/RealmOps';
 import ReconOps, { Recon } from '../ops/ReconOps';
 import ResourceTypeOps, { ResourceType } from '../ops/ResourceTypeOps';
@@ -182,6 +183,8 @@ export type Frodo = {
     issuer: OAuth2TrustedJwtIssuer;
   };
 
+  raw: Raw;
+
   realm: Realm;
 
   role: InternalRole;
@@ -354,6 +357,8 @@ const FrodoLib = (config: StateInterface = {}): Frodo => {
       issuer: OAuth2TrustedJwtIssuerOps(state),
     },
 
+    raw: RawOps(state),
+
     realm: RealmOps(state),
 
     role: InternalRoleOps(state),

src/ops/ConfigOps.ts

@@ -412,7 +412,7 @@ export async function exportFullConfiguration({
       emailTemplate: (
         await exportWithErrorHandling(
           exportEmailTemplates,
-          stateObj,
+          { includeDefault: includeReadOnly, state },
           'Email Templates',
           resultCallback,
           isPlatformDeployment

src/ops/EmailTemplateOps.test.ts

@@ -174,7 +174,14 @@ describe('EmailTemplateOps', () => {
     });
 
     test('1: Export email templates', async () => {
-      const response = await EmailTemplateOps.exportEmailTemplates({ state });
+      const response = await EmailTemplateOps.exportEmailTemplates({ includeDefault: false, state });
+      expect(response).toMatchSnapshot({
+        meta: expect.any(Object)
+      });
+    });
+
+    test('2: Export email templates with default templates', async () => {
+      const response = await EmailTemplateOps.exportEmailTemplates({ includeDefault: true, state });
       expect(response).toMatchSnapshot({
         meta: expect.any(Object)
       });

src/ops/EmailTemplateOps.ts

@@ -32,9 +32,12 @@ export type EmailTemplate = {
   createEmailTemplateExportTemplate(): EmailTemplateExportInterface;
   /**
    * Get all email templates
+   * @param {boolean} includeDefault Include default email templates if true, false to exclude them. Default: false
    * @returns {Promise<EmailTemplateSkeleton[]>} a promise that resolves to an array of email template objects
    */
-  readEmailTemplates(): Promise<EmailTemplateSkeleton[]>;
+  readEmailTemplates(
+    includeDefault?: boolean
+  ): Promise<EmailTemplateSkeleton[]>;
   /**
    * Get email template
    * @param {string} templateId id/name of the email template without the type prefix
@@ -43,9 +46,12 @@ export type EmailTemplate = {
   readEmailTemplate(templateId: string): Promise<EmailTemplateSkeleton>;
   /**
    * Export all email templates. The response can be saved to file as is.
+   * @param {boolean} includeDefault Include default email templates if true, false to exclude them. Default: false
    * @returns {Promise<EmailTemplateExportInterface>} Promise resolving to a EmailTemplateExportInterface object.
    */
-  exportEmailTemplates(): Promise<EmailTemplateExportInterface>;
+  exportEmailTemplates(
+    includeDefault?: boolean
+  ): Promise<EmailTemplateExportInterface>;
   /**
    * Create email template
    * @param {string} templateId id/name of the email template without the type prefix
@@ -133,14 +139,16 @@ export default (state: State): EmailTemplate => {
     createEmailTemplateExportTemplate(): EmailTemplateExportInterface {
       return createEmailTemplateExportTemplate({ state });
     },
-    async readEmailTemplates(): Promise<any> {
-      return readEmailTemplates({ state });
+    async readEmailTemplates(includeDefault: boolean = false): Promise<any> {
+      return readEmailTemplates({ includeDefault, state });
     },
     async readEmailTemplate(templateId: string): Promise<any> {
       return readEmailTemplate({ templateId, state });
     },
-    async exportEmailTemplates(): Promise<EmailTemplateExportInterface> {
-      return exportEmailTemplates({ state });
+    async exportEmailTemplates(
+      includeDefault: boolean = false
+    ): Promise<EmailTemplateExportInterface> {
+      return exportEmailTemplates({ includeDefault, state });
     },
     async createEmailTemplate(
       templateId: string,
@@ -218,16 +226,20 @@ export function createEmailTemplateExportTemplate({
 
 /**
  * Get all email templates
+ * @param {boolean} includeDefault Include default email templates if true, false to exclude them. Default: false
  * @returns {Promise<EmailTemplateSkeleton[]>} a promise that resolves to an array of email template objects
  */
 export async function readEmailTemplates({
+  includeDefault = false,
   state,
 }: {
+  includeDefault?: boolean;
   state: State;
 }): Promise<EmailTemplateSkeleton[]> {
   try {
     const templates = await readConfigEntitiesByType({
       type: EMAIL_TEMPLATE_TYPE,
+      includeDefault,
       state,
     });
     return templates as EmailTemplateSkeleton[];
@@ -260,11 +272,14 @@ export async function readEmailTemplate({
 
 /**
  * Export all email templates. The response can be saved to file as is.
+ * @param {boolean} includeDefault Include default email templates if true, false to exclude them. Default: false
  * @returns {Promise<EmailTemplateExportInterface>} Promise resolving to a EmailTemplateExportInterface object.
  */
 export async function exportEmailTemplates({
+  includeDefault = false,
   state,
 }: {
+  includeDefault: boolean;
   state: State;
 }): Promise<EmailTemplateExportInterface> {
   try {
@@ -273,7 +288,7 @@ export async function exportEmailTemplates({
       state,
     });
     const exportData = createEmailTemplateExportTemplate({ state });
-    const emailTemplates = await readEmailTemplates({ state });
+    const emailTemplates = await readEmailTemplates({ includeDefault, state });
     const indicatorId = createProgressIndicator({
       total: emailTemplates.length,
       message: 'Exporting email templates...',

src/ops/IdmConfigOps.test.ts

@@ -221,6 +221,15 @@ describe('IdmConfigOps', () => {
       });
       expect(response).toMatchSnapshot();
     });
+
+    test('3: Read config entity by type (emailTemplate with default templates)', async () => {
+      const response = await IdmConfigOps.readConfigEntitiesByType({
+        type: 'emailTemplate',
+        includeDefault: true,
+        state,
+      });
+      expect(response).toMatchSnapshot();
+    });
   });
 
   describe('readConfigEntity()', () => {

src/ops/IdmConfigOps.ts

@@ -53,9 +53,13 @@ export type IdmConfig = {
   /**
    * Read all config entities of a type
    * @param {string} type config entity type
+   * @param {boolean} includeDefault Include default email templates if true, false to exclude them. Default: false
    * @returns {IdObjectSkeletonInterface[]} promise resolving to an array of config entities of a type
    */
-  readConfigEntitiesByType(type: string): Promise<IdObjectSkeletonInterface[]>;
+  readConfigEntitiesByType(
+    type: string,
+    includeDefault?: boolean
+  ): Promise<IdObjectSkeletonInterface[]>;
   /**
    * Read config entity
    * @param {string} entityId config entity id/name
@@ -249,9 +253,10 @@ export default (state: State): IdmConfig => {
       return readConfigEntities({ state });
     },
     async readConfigEntitiesByType(
-      type: string
+      type: string,
+      includeDefault: boolean = false
     ): Promise<IdObjectSkeletonInterface[]> {
-      return readConfigEntitiesByType({ type, state });
+      return readConfigEntitiesByType({ type, includeDefault, state });
     },
     async readConfigEntity(
       entityId: string
@@ -478,13 +483,19 @@ export async function readConfigEntities({
 
 export async function readConfigEntitiesByType({
   type,
+  includeDefault = false,
   state,
 }: {
   type: string;
+  includeDefault?: boolean;
   state: State;
 }): Promise<NoIdObjectSkeletonInterface[]> {
   try {
-    const { result } = await _getConfigEntitiesByType({ type, state });
+    const { result } = await _getConfigEntitiesByType({
+      type,
+      includeDefault,
+      state,
+    });
     return result;
   } catch (error) {
     throw new FrodoError(`Error reading config entities by type`, error);

src/ops/RawOps.ts

@@ -0,0 +1,85 @@
+import { IdObjectSkeletonInterface } from '../api/ApiTypes';
+import { restGetRawAm, restGetRawEnv, restGetRawIdm } from '../api/RawApi';
+import { State } from '../shared/State';
+import { debugMessage } from '../utils/Console';
+import { FrodoError } from './FrodoError';
+
+export type Raw = {
+  exportRawIdm(url: string): Promise<IdObjectSkeletonInterface>;
+  exportRawAm(url: string): Promise<IdObjectSkeletonInterface>;
+  exportRawEnv(url: string): Promise<IdObjectSkeletonInterface>;
+};
+
+export default (state: State) => {
+  return {
+    async exportRawIdm(url: string) {
+      return exportRawIdm({ state, url });
+    },
+    async exportRawAm(url: string) {
+      return exportRawAm({ state, url });
+    },
+    async exportRawEnv(url: string) {
+      return exportRawEnv({ state, url });
+    },
+  };
+};
+
+export async function exportRawIdm({
+  state,
+  url,
+}: {
+  state: State;
+  url: string;
+}): Promise<IdObjectSkeletonInterface> {
+  try {
+    debugMessage({ message: `Raw.exportRawIdm: start`, state });
+    const raw = await restGetRawIdm({ state, url });
+    debugMessage({ message: `Raw.exportRawIdm: end`, state });
+    return raw;
+  } catch (error) {
+    throw new FrodoError(
+      `Error in exportRawIdm with relative url: ${url}`,
+      error
+    );
+  }
+}
+
+export async function exportRawAm({
+  state,
+  url,
+}: {
+  state: State;
+  url: string;
+}): Promise<IdObjectSkeletonInterface> {
+  try {
+    debugMessage({ message: `Raw.exportRawAm: start`, state });
+    const raw = await restGetRawAm({ state, url });
+    debugMessage({ message: `Raw.exportRawAm: end`, state });
+    return raw;
+  } catch (error) {
+    throw new FrodoError(
+      `Error in exportRawAm with relative url: ${url}`,
+      error
+    );
+  }
+}
+
+export async function exportRawEnv({
+  state,
+  url,
+}: {
+  state: State;
+  url: string;
+}): Promise<IdObjectSkeletonInterface> {
+  try {
+    debugMessage({ message: `Raw.exportRawEnv: start`, state });
+    const raw = await restGetRawEnv({ state, url });
+    debugMessage({ message: `Raw.exportRawEnv: end`, state });
+    return raw;
+  } catch (error) {
+    throw new FrodoError(
+      `Error in exportRawEnv with relative url: ${url}`,
+      error
+    );
+  }
+}