@rockcarver/frodo-lib 0.19.2 → 2.0.0-1

package/esm/ops/PolicyOps.mjs

@@ -1,4 +1,4 @@
-import { getPolicies as _getPolicies, getPoliciesByPolicySet as _getPoliciesByPolicySet, getPolicy as _getPolicy, putPolicy as _putPolicy, deletePolicy as _deletePolicy } from '../api/PoliciesApi';
+import { getPolicies as _getPolicies, getPoliciesByPolicySet as _getPoliciesByPolicySet, getPolicy, putPolicy, deletePolicy } from '../api/PoliciesApi';
 import { getScript, putScript } from './ScriptOps';
 import { convertBase64TextToArray } from './utils/ExportImportUtils';
 import { PolicyConditionType } from '../api/ApiTypes';
@@ -7,6 +7,156 @@ import { debugMessage } from './utils/Console';
 import { getResourceType } from '../api/ResourceTypesApi';
 import { createPolicySet, getPolicySet, updatePolicySet } from './PolicySetOps';
 import { createResourceType, updateResourceType } from './ResourceTypeOps';
+export default class PolicyOps {
+  constructor(state) {
+    this.state = state;
+  }
+
+  /**
+   * Get all policies
+   * @returns {Promise<PolicySkeleton>} a promise that resolves to an array of policy set objects
+   */
+  async getPolicies() {
+    return getPolicies({
+      state: this.state
+    });
+  }
+
+  /**
+   * Get policies by policy set
+   * @param {string} policySetId policy set id/name
+   * @returns {Promise<PolicySkeleton[]>} a promise resolving to an array of policy objects
+   */
+  async getPoliciesByPolicySet(policySetId) {
+    return getPoliciesByPolicySet({
+      policySetId,
+      state: this.state
+    });
+  }
+  async getPolicy(policyId) {
+    return getPolicy({
+      policyId,
+      state: this.state
+    });
+  }
+  async putPolicy(policyId, policyData) {
+    return putPolicy({
+      policyId,
+      policyData,
+      state: this.state
+    });
+  }
+  async deletePolicy(policyId) {
+    return deletePolicy({
+      policyId,
+      state: this.state
+    });
+  }
+
+  /**
+   * Export policy
+   * @param {string} policyId policy id/name
+   * @returns {Promise<PolicyExportInterface>} a promise that resolves to a PolicyExportInterface object
+   */
+  async exportPolicy(policyId, options = {
+    deps: true,
+    prereqs: false,
+    useStringArrays: true
+  }) {
+    return exportPolicy({
+      policyId,
+      options,
+      state: this.state
+    });
+  }
+
+  /**
+   * Export policies
+   * @param {PolicyExportOptions} options export options
+   * @returns {Promise<PolicyExportInterface>} a promise that resolves to an PolicyExportInterface object
+   */
+  async exportPolicies(options = {
+    deps: true,
+    prereqs: false,
+    useStringArrays: true
+  }) {
+    return exportPolicies({
+      options,
+      state: this.state
+    });
+  }
+
+  /**
+   * Export policies by policy set
+   * @param {string} policySetName policy set id/name
+   * @param {PolicyExportOptions} options export options
+   * @returns {Promise<PolicyExportInterface>} a promise that resolves to an PolicyExportInterface object
+   */
+  async exportPoliciesByPolicySet(policySetName, options = {
+    deps: true,
+    prereqs: false,
+    useStringArrays: true
+  }) {
+    return exportPoliciesByPolicySet({
+      policySetName,
+      options,
+      state: this.state
+    });
+  }
+
+  /**
+   * Import policy by id
+   * @param {string} policyId policy id
+   * @param {PolicyExportInterface} importData import data
+   * @param {PolicyImportOptions} options import options
+   * @returns {Promise<PolicySkeleton>} imported policy object
+   */
+  async importPolicy(policyId, importData, options = {
+    deps: true,
+    prereqs: false
+  }) {
+    return importPolicy({
+      policyId,
+      importData,
+      options,
+      state: this.state
+    });
+  }
+
+  /**
+   * Import first policy
+   * @param {PolicyExportInterface} importData import data
+   * @param {PolicyImportOptions} options import options
+   * @returns {Promise<PolicySkeleton>} imported policy object
+   */
+  async importFirstPolicy(importData, options = {
+    deps: true,
+    prereqs: false
+  }) {
+    return importFirstPolicy({
+      importData,
+      options,
+      state: this.state
+    });
+  }
+
+  /**
+   * Import policies
+   * @param {PolicyExportInterface} importData import data
+   * @param {PolicyImportOptions} options import options
+   * @returns {Promise<PolicySkeleton[]>} array of imported policy objects
+   */
+  async importPolicies(importData, options = {
+    deps: true,
+    prereqs: false
+  }) {
+    return importPolicies({
+      importData,
+      options,
+      state: this.state
+    });
+  }
+}
 
 /**
  * Policy export options
@@ -20,9 +170,13 @@ import { createResourceType, updateResourceType } from './ResourceTypeOps';
  * Create an empty export template
  * @returns {PolicyExportInterface} an empty export template
  */
-function createPolicyExportTemplate() {
+function createPolicyExportTemplate({
+  state
+}) {
   return {
-    meta: getMetadata(),
+    meta: getMetadata({
+      state
+    }),
     script: {},
     policy: {},
     resourcetype: {},
@@ -34,10 +188,14 @@ function createPolicyExportTemplate() {
  * Get all policies
  * @returns {Promise<PolicySkeleton>} a promise that resolves to an array of policy set objects
  */
-export async function getPolicies() {
+export async function getPolicies({
+  state
+}) {
   const {
     result
-  } = await _getPolicies();
+  } = await _getPolicies({
+    state
+  });
   return result;
 }
 
@@ -46,38 +204,17 @@ export async function getPolicies() {
  * @param {string} policySetId policy set id/name
  * @returns {Promise<PolicySkeleton[]>} a promise resolving to an array of policy objects
  */
-export async function getPoliciesByPolicySet(policySetId) {
-  const data = await _getPoliciesByPolicySet(policySetId);
+export async function getPoliciesByPolicySet({
+  policySetId,
+  state
+}) {
+  const data = await _getPoliciesByPolicySet({
+    policySetId,
+    state
+  });
   return data.result;
 }
-
-/**
- * Get policy
- * @param {string} policyId policy id/name
- * @returns {Promise<PolicySkeleton>} a promise that resolves to a policy object
- */
-export async function getPolicy(policyId) {
-  return _getPolicy(policyId);
-}
-
-/**
- * Put policy
- * @param {string} policyId policy id/name
- * @param {PolicySkeleton} policyData policy object
- * @returns {Promise<PolicySkeleton>} a promise that resolves to a policy object
- */
-export async function putPolicy(policyId, policyData) {
-  return _putPolicy(policyId, policyData);
-}
-
-/**
- * Delete policy
- * @param {string} policyId policy id/name
- * @returns {Promise<PolicySkeleton>} a promise that resolves to a policy object
- */
-export async function deletePolicy(policyId) {
-  return _deletePolicy(policyId);
-}
+export { getPolicy, putPolicy, deletePolicy };
 
 /**
  * Find all script references in a deeply-nested policy condition object
@@ -150,7 +287,10 @@ export function findScriptUuids(condition) {
  * @param {PolicySkeleton} policyData policy object
  * @returns {Promise<ScriptSkeleton[]>} a promise that resolves to an array of script objects
  */
-export async function getScripts(policyData) {
+export async function getScripts({
+  policyData,
+  state
+}) {
   debugMessage(`PolicyOps.getScripts: start [policy=${policyData['name']}]`);
   const errors = [];
   const scripts = [];
@@ -159,7 +299,10 @@ export async function getScripts(policyData) {
     debugMessage(`found scripts: ${scriptUuids}`);
     for (const scriptUuid of scriptUuids) {
       try {
-        const script = await getScript(scriptUuid);
+        const script = await getScript({
+          scriptId: scriptUuid,
+          state
+        });
         scripts.push(script);
       } catch (error) {
         error.message = `Error retrieving script ${scriptUuid} referenced in policy ${policyData['name']}: ${error.message}`;
@@ -180,20 +323,29 @@ export async function getScripts(policyData) {
 
 /**
  * Helper function to export dependencies of a policy set
- * @param {unknown} policyData policy set data
- * @param {PolicyExportOptions} options export options
+ * @param {PolicySkeleton} policyData policy set data
  * @param {PolicyExportInterface} exportData export data
  */
-async function exportPolicyPrerequisites(policyData, exportData) {
+async function exportPolicyPrerequisites({
+  policyData,
+  exportData,
+  state
+}) {
   debugMessage(`PolicyOps.exportPolicyPrerequisites: start [policy=${policyData['name']}]`);
   // resource types
   if (policyData.resourceTypeUuid) {
-    const resourceType = await getResourceType(policyData.resourceTypeUuid);
+    const resourceType = await getResourceType({
+      resourceTypeUuid: policyData.resourceTypeUuid,
+      state
+    });
     exportData.resourcetype[policyData.resourceTypeUuid] = resourceType;
   }
   // policy set
   if (policyData.applicationName) {
-    const policySet = await getPolicySet(policyData.applicationName);
+    const policySet = await getPolicySet({
+      policySetName: policyData.applicationName,
+      state
+    });
     exportData.policyset[policyData.applicationName] = policySet;
   }
   debugMessage(`PolicySetOps.exportPolicyPrerequisites: end`);
@@ -205,10 +357,18 @@ async function exportPolicyPrerequisites(policyData, exportData) {
  * @param {PolicyExportOptions} options export options
  * @param {PolicyExportInterface} exportData export data
  */
-async function exportPolicyDependencies(policyData, options, exportData) {
+async function exportPolicyDependencies({
+  policyData,
+  options,
+  exportData,
+  state
+}) {
   debugMessage(`PolicyOps.exportPolicyDependencies: start [policy=${policyData['name']}]`);
   // scripts
-  const scripts = await getScripts(policyData);
+  const scripts = await getScripts({
+    policyData,
+    state
+  });
   for (const scriptData of scripts) {
     if (options.useStringArrays) {
       scriptData.script = convertBase64TextToArray(scriptData.script);
@@ -223,20 +383,38 @@ async function exportPolicyDependencies(policyData, options, exportData) {
  * @param {string} policyId policy id/name
  * @returns {Promise<PolicyExportInterface>} a promise that resolves to a PolicyExportInterface object
  */
-export async function exportPolicy(policyId, options = {
-  deps: true,
-  prereqs: false,
-  useStringArrays: true
+export async function exportPolicy({
+  policyId,
+  options = {
+    deps: true,
+    prereqs: false,
+    useStringArrays: true
+  },
+  state
 }) {
   debugMessage(`PolicyOps.exportPolicy: start`);
-  const policyData = await getPolicy(policyId);
-  const exportData = createPolicyExportTemplate();
+  const policyData = await getPolicy({
+    policyId,
+    state
+  });
+  const exportData = createPolicyExportTemplate({
+    state
+  });
   exportData.policy[policyData._id] = policyData;
   if (options.prereqs) {
-    await exportPolicyPrerequisites(policyData, exportData);
+    await exportPolicyPrerequisites({
+      policyData,
+      exportData,
+      state
+    });
   }
   if (options.deps) {
-    await exportPolicyDependencies(policyData, options, exportData);
+    await exportPolicyDependencies({
+      policyData,
+      options,
+      exportData,
+      state
+    });
   }
   debugMessage(`PolicyOps.exportPolicy: end`);
   return exportData;
@@ -247,28 +425,44 @@ export async function exportPolicy(policyId, options = {
  * @param {PolicyExportOptions} options export options
  * @returns {Promise<PolicyExportInterface>} a promise that resolves to an PolicyExportInterface object
  */
-export async function exportPolicies(options = {
-  deps: true,
-  prereqs: false,
-  useStringArrays: true
+export async function exportPolicies({
+  options = {
+    deps: true,
+    prereqs: false,
+    useStringArrays: true
+  },
+  state
 }) {
   debugMessage(`PolicyOps.exportPolicies: start`);
-  const exportData = createPolicyExportTemplate();
+  const exportData = createPolicyExportTemplate({
+    state
+  });
   const errors = [];
   try {
-    const policies = await getPolicies();
+    const policies = await getPolicies({
+      state
+    });
     for (const policyData of policies) {
       exportData.policy[policyData._id] = policyData;
       if (options.prereqs) {
         try {
-          await exportPolicyPrerequisites(policyData, exportData);
+          await exportPolicyPrerequisites({
+            policyData,
+            exportData,
+            state
+          });
         } catch (error) {
           errors.push(error);
         }
       }
       if (options.deps) {
         try {
-          await exportPolicyDependencies(policyData, options, exportData);
+          await exportPolicyDependencies({
+            policyData,
+            options,
+            exportData,
+            state
+          });
         } catch (error) {
           errors.push(error);
         }
@@ -291,28 +485,46 @@ export async function exportPolicies(options = {
  * @param {PolicyExportOptions} options export options
  * @returns {Promise<PolicyExportInterface>} a promise that resolves to an PolicyExportInterface object
  */
-export async function exportPoliciesByPolicySet(policySetName, options = {
-  deps: true,
-  prereqs: false,
-  useStringArrays: true
+export async function exportPoliciesByPolicySet({
+  policySetName,
+  options = {
+    deps: true,
+    prereqs: false,
+    useStringArrays: true
+  },
+  state
 }) {
   debugMessage(`PolicyOps.exportPolicies: start`);
-  const exportData = createPolicyExportTemplate();
+  const exportData = createPolicyExportTemplate({
+    state
+  });
   const errors = [];
   try {
-    const policies = await getPoliciesByPolicySet(policySetName);
+    const policies = await getPoliciesByPolicySet({
+      policySetId: policySetName,
+      state
+    });
     for (const policyData of policies) {
       exportData.policy[policyData._id] = policyData;
       if (options.prereqs) {
         try {
-          await exportPolicyPrerequisites(policyData, exportData);
+          await exportPolicyPrerequisites({
+            policyData,
+            exportData,
+            state
+          });
         } catch (error) {
           errors.push(error);
         }
       }
       if (options.deps) {
         try {
-          await exportPolicyDependencies(policyData, options, exportData);
+          await exportPolicyDependencies({
+            policyData,
+            options,
+            exportData,
+            state
+          });
         } catch (error) {
           errors.push(error);
         }
@@ -334,7 +546,11 @@ export async function exportPoliciesByPolicySet(policySetName, options = {
  * @param {PolicySkeleton} policyData policy object
  * @param {PolicyExportInterface} exportData export data
  */
-async function importPolicyPrerequisites(policyData, exportData) {
+async function importPolicyPrerequisites({
+  policyData,
+  exportData,
+  state
+}) {
   debugMessage(`PolicyOps.importPolicyHardDependencies: start [policy=${policyData._id}]`);
   const errors = [];
   try {
@@ -342,20 +558,33 @@ async function importPolicyPrerequisites(policyData, exportData) {
     if (exportData.resourcetype[policyData.resourceTypeUuid]) {
       try {
         debugMessage(`Importing resource type ${policyData.resourceTypeUuid}`);
-        await createResourceType(exportData.resourcetype[policyData.resourceTypeUuid]);
+        await createResourceType({
+          resourceTypeData: exportData.resourcetype[policyData.resourceTypeUuid],
+          state
+        });
       } catch (error) {
         var _error$response;
-        if (((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.status) === 409) await updateResourceType(policyData.resourceTypeUuid, exportData.resourcetype[policyData.resourceTypeUuid]);else throw error;
+        if (((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.status) === 409) await updateResourceType({
+          resourceTypeUuid: policyData.resourceTypeUuid,
+          resourceTypeData: exportData.resourcetype[policyData.resourceTypeUuid],
+          state
+        });else throw error;
       }
     }
     // policy set
     if (exportData.policyset[policyData.applicationName]) {
       try {
         debugMessage(`Importing policy set ${policyData.applicationName}`);
-        await createPolicySet(exportData.policyset[policyData.applicationName]);
+        await createPolicySet({
+          policySetData: exportData.policyset[policyData.applicationName],
+          state
+        });
       } catch (error) {
         var _error$response2;
-        if (((_error$response2 = error.response) === null || _error$response2 === void 0 ? void 0 : _error$response2.status) === 409) await updatePolicySet(exportData.policyset[policyData.applicationName]);else throw error;
+        if (((_error$response2 = error.response) === null || _error$response2 === void 0 ? void 0 : _error$response2.status) === 409) await updatePolicySet({
+          policySetData: exportData.policyset[policyData.applicationName],
+          state
+        });else throw error;
       }
     }
   } catch (error) {
@@ -378,7 +607,11 @@ async function importPolicyPrerequisites(policyData, exportData) {
  * @param {PolicySkeleton} policyData policy object
  * @param {PolicyExportInterface} exportData export data
  */
-async function importPolicyDependencies(policyData, exportData) {
+async function importPolicyDependencies({
+  policyData,
+  exportData,
+  state
+}) {
   debugMessage(`PolicyOps.importPolicySoftDependencies: start [policy=${policyData._id}]`);
   const errors = [];
   try {
@@ -388,7 +621,11 @@ async function importPolicyDependencies(policyData, exportData) {
       try {
         const scriptData = exportData.script[scriptUuid];
         debugMessage(`Importing script ${scriptUuid}`);
-        await putScript(scriptUuid, scriptData);
+        await putScript({
+          scriptId: scriptUuid,
+          scriptData,
+          state
+        });
       } catch (error) {
         var _error$response5, _error$response6, _error$response6$data;
         debugMessage((_error$response5 = error.response) === null || _error$response5 === void 0 ? void 0 : _error$response5.data);
@@ -418,9 +655,14 @@ async function importPolicyDependencies(policyData, exportData) {
  * @param {PolicyImportOptions} options import options
  * @returns {Promise<PolicySkeleton>} imported policy object
  */
-export async function importPolicy(policyId, importData, options = {
-  deps: true,
-  prereqs: false
+export async function importPolicy({
+  policyId,
+  importData,
+  options = {
+    deps: true,
+    prereqs: false
+  },
+  state
 }) {
   let response = null;
   const errors = [];
@@ -435,20 +677,32 @@ export async function importPolicy(policyId, importData, options = {
         }
         if (options.prereqs) {
           try {
-            await importPolicyPrerequisites(policyData, importData);
+            await importPolicyPrerequisites({
+              policyData,
+              exportData: importData,
+              state
+            });
           } catch (error) {
             errors.push(error);
           }
         }
         try {
-          response = await putPolicy(policyData._id, policyData);
+          response = await putPolicy({
+            policyId: policyData._id,
+            policyData,
+            state
+          });
           imported.push(id);
         } catch (error) {
           errors.push(error);
         }
         if (options.deps) {
           try {
-            await importPolicyDependencies(policyData, importData);
+            await importPolicyDependencies({
+              policyData,
+              exportData: importData,
+              state
+            });
           } catch (error) {
             errors.push(error);
           }
@@ -477,9 +731,13 @@ export async function importPolicy(policyId, importData, options = {
  * @param {PolicyImportOptions} options import options
  * @returns {Promise<PolicySkeleton>} imported policy object
  */
-export async function importFirstPolicy(importData, options = {
-  deps: true,
-  prereqs: false
+export async function importFirstPolicy({
+  importData,
+  options = {
+    deps: true,
+    prereqs: false
+  },
+  state
 }) {
   let response = null;
   const errors = [];
@@ -493,20 +751,32 @@ export async function importFirstPolicy(importData, options = {
       }
       if (options.prereqs) {
         try {
-          await importPolicyPrerequisites(policyData, importData);
+          await importPolicyPrerequisites({
+            policyData,
+            exportData: importData,
+            state
+          });
         } catch (error) {
           errors.push(error);
         }
       }
       try {
-        response = await putPolicy(policyData._id, policyData);
+        response = await putPolicy({
+          policyId: policyData._id,
+          policyData,
+          state
+        });
         imported.push(id);
       } catch (error) {
         errors.push(error);
       }
       if (options.deps) {
         try {
-          await importPolicyDependencies(policyData, importData);
+          await importPolicyDependencies({
+            policyData,
+            exportData: importData,
+            state
+          });
         } catch (error) {
           errors.push(error);
         }
@@ -535,9 +805,13 @@ export async function importFirstPolicy(importData, options = {
  * @param {PolicyImportOptions} options import options
  * @returns {Promise<PolicySkeleton[]>} array of imported policy objects
  */
-export async function importPolicies(importData, options = {
-  deps: true,
-  prereqs: false
+export async function importPolicies({
+  importData,
+  options = {
+    deps: true,
+    prereqs: false
+  },
+  state
 }) {
   const response = [];
   const errors = [];
@@ -551,20 +825,32 @@ export async function importPolicies(importData, options = {
       }
       if (options.prereqs) {
         try {
-          await importPolicyPrerequisites(policyData, importData);
+          await importPolicyPrerequisites({
+            policyData,
+            exportData: importData,
+            state
+          });
         } catch (error) {
           errors.push(error);
         }
       }
       try {
-        response.push(await putPolicy(policyData._id, policyData));
+        response.push(await putPolicy({
+          policyId: policyData._id,
+          policyData,
+          state
+        }));
         imported.push(id);
       } catch (error) {
         errors.push(error);
       }
       if (options.deps) {
         try {
-          await importPolicyDependencies(policyData, importData);
+          await importPolicyDependencies({
+            policyData,
+            exportData: importData,
+            state
+          });
         } catch (error) {
           errors.push(error);
         }