@rockcarver/frodo-lib 1.0.0 → 2.0.0-1

package/esm/ops/ScriptOps.mjs

@@ -1,16 +1,124 @@
 import { v4 as uuidv4 } from 'uuid';
 import { applyNameCollisionPolicy } from './utils/OpsUtils';
 import { createProgressIndicator, debugMessage, printMessage, stopProgressIndicator, updateProgressIndicator } from './utils/Console';
-import { getScript as _getScript, getScriptByName as _getScriptByName, getScripts as _getScripts, putScript as _putScript, deleteScript as _deleteScript } from '../api/ScriptApi';
+import { getScript, getScriptByName as _getScriptByName, getScripts as _getScripts, putScript as _putScript, deleteScript } from '../api/ScriptApi';
 import { convertBase64TextToArray, convertTextArrayToBase64, getMetadata } from './utils/ExportImportUtils';
-import { validateScriptDecoded } from './utils/ValidationUtils';
+import { validateScriptDecoded } from './utils/ScriptValidationUtils';
+export default class ScriptOps {
+  constructor(state) {
+    this.state = state;
+  }
+
+  /**
+   * Get all scripts
+   * @returns {Promise<ScriptSkeleton[]>} a promise that resolves to an array of script objects
+   */
+  async getScripts() {
+    return getScripts({
+      state: this.state
+    });
+  }
+
+  /**
+   * Get script by name
+   * @param {string} name name of the script
+   * @returns {Promise<ScriptSkeleton>} promise that resolves to a script object
+   */
+  async getScriptByName(scriptName) {
+    return getScriptByName({
+      scriptName,
+      state: this.state
+    });
+  }
+
+  /**
+   * Create or update script
+   * @param {string} scriptId script uuid
+   * @param {ScriptSkeleton} scriptData script object
+   * @returns {Promise<boolean>} a status object
+   */
+  async putScript(scriptId, scriptData) {
+    return putScript({
+      scriptId,
+      scriptData,
+      state: this.state
+    });
+  }
+
+  /**
+   * Export script by id
+   * @param {string} scriptId script uuid
+   * @returns {Promise<ScriptExportInterface>} a promise that resolved to a ScriptExportInterface object
+   */
+  async exportScript(scriptId) {
+    return exportScript({
+      scriptId,
+      state: this.state
+    });
+  }
+
+  /**
+   * Export script by name
+   * @param {string} name script name
+   * @returns {Promise<ScriptExportInterface>} a promise that resolved to a ScriptExportInterface object
+   */
+  async exportScriptByName(scriptName) {
+    return exportScriptByName({
+      scriptName,
+      state: this.state
+    });
+  }
+
+  /**
+   * Export all scripts
+   * @returns {Promise<ScriptExportInterface>} a promise that resolved to a ScriptExportInterface object
+   */
+  async exportScripts() {
+    return exportScripts({
+      state: this.state
+    });
+  }
+
+  /**
+   * Import scripts
+   * @param {string} scriptName Optional name of script. If supplied, only the script of that name is imported
+   * @param {ScriptExportInterface} importData Script import data
+   * @param {boolean} reUuid true to generate a new uuid for each script on import, false otherwise
+   * @returns {Promise<boolean>} true if no errors occurred during import, false otherwise
+   */
+  async importScripts(scriptName, importData, reUuid = false, validate = false) {
+    return importScripts({
+      scriptName,
+      importData,
+      reUuid,
+      validate,
+      state: this.state
+    });
+  }
+  getScript(scriptId) {
+    return getScript({
+      scriptId,
+      state: this.state
+    });
+  }
+  deleteScript(scriptId) {
+    return deleteScript({
+      scriptId,
+      state: this.state
+    });
+  }
+}
 /**
  * Create an empty idp export template
  * @returns {ScriptExportInterface} an empty idp export template
  */
-export function createScriptExportTemplate() {
+export function createScriptExportTemplate({
+  state
+}) {
   return {
-    meta: getMetadata(),
+    meta: getMetadata({
+      state
+    }),
     script: {}
   };
 }
@@ -19,39 +127,39 @@ export function createScriptExportTemplate() {
  * Get all scripts
  * @returns {Promise<ScriptSkeleton[]>} a promise that resolves to an array of script objects
  */
-export async function getScripts() {
+export async function getScripts({
+  state
+}) {
   const {
     result
-  } = await _getScripts();
+  } = await _getScripts({
+    state
+  });
   return result;
 }
 
-/**
- * Get script by id
- * @param {string} scriptId script uuid
- * @returns {Promise<ScriptSkeleton>} promise that resolves to a script object
- */
-export async function getScript(scriptId) {
-  const response = await _getScript(scriptId);
-  return response;
-}
-
 /**
  * Get script by name
- * @param {string} name name of the script
+ * @param {string} scriptName name of the script
  * @returns {Promise<ScriptSkeleton>} promise that resolves to a script object
  */
-export async function getScriptByName(name) {
+export async function getScriptByName({
+  scriptName,
+  state
+}) {
   const {
     result
-  } = await _getScriptByName(name);
+  } = await _getScriptByName({
+    scriptName,
+    state
+  });
   switch (result.length) {
     case 1:
       return result[0];
     case 0:
-      throw new Error(`Script '${name}' not found`);
+      throw new Error(`Script '${scriptName}' not found`);
     default:
-      throw new Error(`${result.length} scripts '${name}' found`);
+      throw new Error(`${result.length} scripts '${scriptName}' found`);
   }
 }
 
@@ -61,12 +169,20 @@ export async function getScriptByName(name) {
  * @param {ScriptSkeleton} scriptData script object
  * @returns {Promise<boolean>} a status object
  */
-export async function putScript(scriptId, scriptData) {
+export async function putScript({
+  scriptId,
+  scriptData,
+  state
+}) {
   try {
     if (Array.isArray(scriptData.script)) {
       scriptData.script = convertTextArrayToBase64(scriptData.script);
     }
-    const result = await _putScript(scriptId, scriptData);
+    const result = await _putScript({
+      scriptId,
+      scriptData,
+      state
+    });
     return result;
   } catch (error) {
     var _error$response;
@@ -74,7 +190,11 @@ export async function putScript(scriptId, scriptData) {
       printMessage(`createOrUpdateScript WARNING: script with name ${scriptData.name} already exists, using renaming policy... <name> => <name - imported (n)>`, 'warn');
       const newName = applyNameCollisionPolicy(scriptData.name);
       scriptData.name = newName;
-      const result = await putScript(scriptId, scriptData);
+      const result = await putScript({
+        scriptId,
+        scriptData,
+        state
+      });
       printMessage(`Saved script as ${newName}`, 'warn');
       return result;
     }
@@ -82,26 +202,24 @@ export async function putScript(scriptId, scriptData) {
   }
 }
 
-/**
- * Delete script by id
- * @param {string} scriptId script uuid
- * @returns {Promise<ScriptSkeleton>} promise that resolves to a script object
- */
-export async function deleteScript(scriptId) {
-  const response = await _deleteScript(scriptId);
-  return response;
-}
-
 /**
  * Export script by id
  * @param {string} scriptId script uuid
  * @returns {Promise<ScriptExportInterface>} a promise that resolved to a ScriptExportInterface object
  */
-export async function exportScript(scriptId) {
+export async function exportScript({
+  scriptId,
+  state
+}) {
   debugMessage(`ScriptOps.exportScriptById: start`);
-  const scriptData = await _getScript(scriptId);
+  const scriptData = await getScript({
+    scriptId,
+    state
+  });
   scriptData.script = convertBase64TextToArray(scriptData.script);
-  const exportData = createScriptExportTemplate();
+  const exportData = createScriptExportTemplate({
+    state
+  });
   exportData.script[scriptData._id] = scriptData;
   debugMessage(`ScriptOps.exportScriptById: end`);
   return exportData;
@@ -109,14 +227,22 @@ export async function exportScript(scriptId) {
 
 /**
  * Export script by name
- * @param {string} name script name
+ * @param {string} scriptName script name
  * @returns {Promise<ScriptExportInterface>} a promise that resolved to a ScriptExportInterface object
  */
-export async function exportScriptByName(name) {
+export async function exportScriptByName({
+  scriptName,
+  state
+}) {
   debugMessage(`ScriptOps.exportScriptByName: start`);
-  const scriptData = await getScriptByName(name);
+  const scriptData = await getScriptByName({
+    scriptName,
+    state
+  });
   scriptData.script = convertBase64TextToArray(scriptData.script);
-  const exportData = createScriptExportTemplate();
+  const exportData = createScriptExportTemplate({
+    state
+  });
   exportData.script[scriptData._id] = scriptData;
   debugMessage(`ScriptOps.exportScriptByName: end`);
   return exportData;
@@ -126,13 +252,22 @@ export async function exportScriptByName(name) {
  * Export all scripts
  * @returns {Promise<ScriptExportInterface>} a promise that resolved to a ScriptExportInterface object
  */
-export async function exportScripts() {
-  const scriptList = await getScripts();
-  const exportData = createScriptExportTemplate();
+export async function exportScripts({
+  state
+}) {
+  const scriptList = await getScripts({
+    state
+  });
+  const exportData = createScriptExportTemplate({
+    state
+  });
   createProgressIndicator(scriptList.length, `Exporting ${scriptList.length} scripts...`);
   for (const script of scriptList) {
     updateProgressIndicator(`Reading script ${script.name}`);
-    const scriptData = await getScriptByName(script.name);
+    const scriptData = await getScriptByName({
+      scriptName: script.name,
+      state
+    });
     scriptData.script = convertBase64TextToArray(scriptData.script);
     exportData.script[scriptData._id] = scriptData;
   }
@@ -142,27 +277,33 @@ export async function exportScripts() {
 
 /**
  * Import scripts
- * @param {string} name Optional name of script. If supplied, only the script of that name is imported
+ * @param {string} scriptName Optional name of script. If supplied, only the script of that name is imported
  * @param {ScriptExportInterface} importData Script import data
  * @param {boolean} reUuid true to generate a new uuid for each script on import, false otherwise
  * @returns {Promise<boolean>} true if no errors occurred during import, false otherwise
  */
-export async function importScripts(name, importData, reUuid = false, shouldValidateScript = false) {
+export async function importScripts({
+  scriptName,
+  importData,
+  reUuid = false,
+  validate = false,
+  state
+}) {
   let outcome = true;
-  debugMessage(`ScriptOps.importScriptsFromFile: start`);
+  debugMessage(`ScriptOps.importScripts: start`);
   for (const existingId of Object.keys(importData.script)) {
     const scriptSkeleton = importData.script[existingId];
     let newId = existingId;
     if (reUuid) {
       newId = uuidv4();
-      debugMessage(`ScriptOps.importScriptsFromFile: Re-uuid-ing script ${scriptSkeleton.name} ${existingId} => ${newId}...`);
+      debugMessage(`ScriptOps.importScripts: Re-uuid-ing script ${scriptSkeleton.name} ${existingId} => ${newId}...`);
       scriptSkeleton._id = newId;
     }
-    if (name) {
-      debugMessage(`ScriptOps.importScriptsFromFile: Renaming script ${scriptSkeleton.name} => ${name}...`);
-      scriptSkeleton.name = name;
+    if (scriptName) {
+      debugMessage(`ScriptOps.importScripts: Renaming script ${scriptSkeleton.name} => ${scriptName}...`);
+      scriptSkeleton.name = scriptName;
     }
-    if (shouldValidateScript) {
+    if (validate) {
       if (!validateScriptDecoded(scriptSkeleton)) {
         outcome = false;
         printMessage(`Error importing script '${scriptSkeleton.name}': Script is not valid`, 'error');
@@ -170,15 +311,20 @@ export async function importScripts(name, importData, reUuid = false, shouldVali
       }
     }
     try {
-      await putScript(newId, scriptSkeleton);
+      await putScript({
+        scriptId: newId,
+        scriptData: scriptSkeleton,
+        state
+      });
     } catch (error) {
       outcome = false;
       printMessage(`Error importing script '${scriptSkeleton.name}': ${error.message}`, 'error');
       debugMessage(error);
     }
-    if (name) break;
+    if (scriptName) break;
   }
-  debugMessage(`ScriptOps.importScriptsFromFile: end`);
+  debugMessage(`ScriptOps.importScripts: end`);
   return outcome;
 }
+export { getScript, deleteScript };
 //# sourceMappingURL=ScriptOps.js.map

package/esm/ops/ScriptOps.test.mjs

@@ -29,19 +29,30 @@
  * Note: FRODO_DEBUG=1 is optional and enables debug logging for some output
  * in case things don't function as expected
  */
-import { Script } from '../index';
+import { state } from '../index';
+import * as ScriptOps from './ScriptOps';
 import { autoSetupPolly } from '../utils/AutoSetupPolly';
 autoSetupPolly();
 async function stageScript(script, create = true) {
   // delete if exists, then create
   try {
-    await Script.getScript(script.id);
-    await Script.deleteScript(script.id);
+    await ScriptOps.getScript({
+      scriptId: script.id,
+      state
+    });
+    await ScriptOps.deleteScript({
+      scriptId: script.id,
+      state
+    });
   } catch (error) {
     // ignore
   } finally {
     if (create) {
-      await Script.putScript(script.id, script.data);
+      await ScriptOps.putScript({
+        scriptId: script.id,
+        scriptData: script.data,
+        state
+      });
     }
   }
 }
@@ -181,10 +192,12 @@ describe('ScriptOps', () => {
   });
   describe('createScriptExportTemplate()', () => {
     test('0: Method is implemented', async () => {
-      expect(Script.createScriptExportTemplate).toBeDefined();
+      expect(ScriptOps.createScriptExportTemplate).toBeDefined();
     });
     test(`1: Create script export template`, async () => {
-      const response = Script.createScriptExportTemplate();
+      const response = ScriptOps.createScriptExportTemplate({
+        state
+      });
       expect(response).toMatchSnapshot({
         meta: expect.any(Object)
       });
@@ -192,46 +205,61 @@ describe('ScriptOps', () => {
   });
   describe('getScripts()', () => {
     test('0: Method is implemented', async () => {
-      expect(Script.getScripts).toBeDefined();
+      expect(ScriptOps.getScripts).toBeDefined();
     });
     test(`1: Get scripts`, async () => {
-      const response = await Script.getScripts();
+      const response = await ScriptOps.getScripts({
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
   describe('getScript()', () => {
     test('0: Method is implemented', async () => {
-      expect(Script.getScript).toBeDefined();
+      expect(ScriptOps.getScript).toBeDefined();
     });
     test(`1: Get script by id '${script1.id}'`, async () => {
-      const response = await Script.getScript(script1.id);
+      const response = await ScriptOps.getScript({
+        scriptId: script1.id,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
   describe('getScriptByName()', () => {
     test('0: Method is implemented', async () => {
-      expect(Script.getScriptByName).toBeDefined();
+      expect(ScriptOps.getScriptByName).toBeDefined();
     });
     test(`1: Get script by name '${script1.name}'`, async () => {
-      const response = await Script.getScriptByName(script1.name);
+      const response = await ScriptOps.getScriptByName({
+        scriptName: script1.name,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
   describe('putScript()', () => {
     test('0: Method is implemented', async () => {
-      expect(Script.putScript).toBeDefined();
+      expect(ScriptOps.putScript).toBeDefined();
     });
     test(`1: Put script '${script3.id}'`, async () => {
-      const response = await Script.putScript(script3.id, script3.data);
+      const response = await ScriptOps.putScript({
+        scriptId: script3.id,
+        scriptData: script3.data,
+        state
+      });
       expect(response).toMatchSnapshot();
     });
   });
   describe('exportScript()', () => {
     test('0: Method is implemented', async () => {
-      expect(Script.exportScript).toBeDefined();
+      expect(ScriptOps.exportScript).toBeDefined();
     });
     test(`1: Export script by id ${script1.id}`, async () => {
-      const response = await Script.exportScript(script1.id);
+      const response = await ScriptOps.exportScript({
+        scriptId: script1.id,
+        state
+      });
       expect(response).toMatchSnapshot({
         meta: expect.any(Object)
       });
@@ -239,10 +267,13 @@ describe('ScriptOps', () => {
   });
   describe('exportScriptByName()', () => {
     test('0: Method is implemented', async () => {
-      expect(Script.exportScriptByName).toBeDefined();
+      expect(ScriptOps.exportScriptByName).toBeDefined();
     });
     test(`1: Export script by name ${script1.name}`, async () => {
-      const response = await Script.exportScriptByName(script1.name);
+      const response = await ScriptOps.exportScriptByName({
+        scriptName: script1.name,
+        state
+      });
       expect(response).toMatchSnapshot({
         meta: expect.any(Object)
       });
@@ -250,10 +281,12 @@ describe('ScriptOps', () => {
   });
   describe('exportScripts()', () => {
     test('0: Method is implemented', async () => {
-      expect(Script.exportScripts).toBeDefined();
+      expect(ScriptOps.exportScripts).toBeDefined();
     });
     test('1: Export all scripts', async () => {
-      const response = await Script.exportScripts();
+      const response = await ScriptOps.exportScripts({
+        state
+      });
       expect(response).toMatchSnapshot({
         meta: expect.any(Object)
       });
@@ -261,16 +294,24 @@ describe('ScriptOps', () => {
   });
   describe('importScripts()', () => {
     test('0: Method is implemented', async () => {
-      expect(Script.importScripts).toBeDefined();
+      expect(ScriptOps.importScripts).toBeDefined();
     });
     test(`1: Import all scripts`, async () => {
       expect.assertions(1);
-      const outcome = await Script.importScripts('', import1.data);
+      const outcome = await ScriptOps.importScripts({
+        scriptName: '',
+        importData: import1.data,
+        state
+      });
       expect(outcome).toBeTruthy();
     });
     test(`2: Import script by name`, async () => {
       expect.assertions(1);
-      const outcome = await Script.importScripts(import1.name, import1.data);
+      const outcome = await ScriptOps.importScripts({
+        scriptName: import1.name,
+        importData: import1.data,
+        state
+      });
       expect(outcome).toBeTruthy();
     });
   });