mstate-cli 0.1.3 → 0.1.6

package/src/handlers/workflow.handler.ts

@@ -23,12 +23,12 @@ class WorkflowHandler {
       const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
 
       if (!file) {
-        customLog.error(`Parameter file is required`);
+        customLog.changeAndThrow(`Parameter file is required`);
         return;
       }
 
       if (!secretKey) {
-        customLog.error(`Parameter secret is required`);
+        customLog.changeAndThrow(`Parameter secret is required`);
         return;
       }
 
@@ -56,106 +56,144 @@ class WorkflowHandler {
 
       const response = await responseJSON.json();
       if (response?.errors) {
-        customLog.error('Invalid Parameters: ', response?.errors);
+        customLog.changeAndThrow(
+          'Invalid Parameters for Workflow: ',
+          ...response?.errors,
+        );
       } else {
         customLog.success('Workflow Added successfully', response?.data);
       }
     } catch (error: any) {
-      customLog.error(error.message);
+      customLog.changeAndThrow(error.message);
     }
   }
 
   async updateWorkflowToDB() {
-    try {
-      const args = process.argv;
+    const args = process.argv;
 
-      const dirPath = getValueFromArgs(args, Key.WORKFLOW);
-      const workflowName = dirPath.replace(/\//g, '__');
-      const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
+    const dirPath = getValueFromArgs(args, Key.WORKFLOW);
+    const workflowName = dirPath.replace(/\//g, '__');
+    const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
 
-      if (!secretKey) {
-        customLog.error(`Parameter secret is required`);
-        return;
-      }
+    if (!secretKey) {
+      customLog.changeAndThrow(`Parameter secret is required`);
+      return;
+    }
 
-      if (!workflowName) {
-        customLog.error(`Parameter workflow is required`);
-        return;
-      }
+    if (!workflowName) {
+      customLog.changeAndThrow(`Parameter workflow is required`);
+      return;
+    }
 
-      const folderPath = path.resolve(dirPath);
-      const filePath = path.join(folderPath, 'workflow.json');
+    const folderPath = path.resolve(dirPath);
+    const filePath = path.join(folderPath, 'workflow.json');
+
+    const workflowJSON = fs.readFileSync(filePath, 'utf8');
+
+    let query = `?workflow=${workflowName}`;
+
+    const url = `${MSTATE_URL}/workflow/config${query}`;
+    const responseJSON = await fetch(url, {
+      method: 'PUT',
+      headers: {
+        'secret-key': secretKey,
+        'Content-Type': 'application/json',
+      },
+      body: workflowJSON,
+    });
+
+    const response = await responseJSON.json();
+    if (response?.errors) {
+      customLog.changeAndThrow(
+        'Invalid Parameters for Server: ',
+        ...response?.errors,
+      );
+    } else {
+      customLog.success('Workflow Uploaded successfully \n', response?.data);
+    }
 
-      const workflowJSON = fs.readFileSync(filePath, 'utf8');
+    return response;
+  }
 
-      let query = `?workflow=${workflowName}`;
+  async cloneWorkflow() {
+    const args = process.argv;
 
-      const url = `${MSTATE_URL}/workflow/config${query}`;
-      const responseJSON = await fetch(url, {
-        method: 'PUT',
-        headers: {
-          'secret-key': secretKey,
-          'Content-Type': 'application/json',
-        },
-        body: workflowJSON,
-      });
+    const dirPath = getValueFromArgs(args, Key.WORKFLOW);
+    const workflowName = dirPath.replace(/\//g, '__');
+    const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
 
-      const response = await responseJSON.json();
-      if (response?.errors) {
-        customLog.error('Invalid Parameters: ', response?.errors);
-      } else {
-        customLog.success('Workflow Uploaded successfully \n', response?.data);
-      }
+    if (!secretKey) {
+      customLog.changeAndThrow(`Parameter secret is required`);
+      return;
+    }
 
-      return response;
-    } catch (error: any) {
-      customLog.error(error.message);
+    if (!workflowName) {
+      customLog.changeAndThrow(`Parameter workflow is required`);
+      return;
     }
-  }
 
-  async cloneWorkflow() {
-    try {
-      const args = process.argv;
+    const url = `${MSTATE_URL}/workflow/config/${workflowName}`;
+    const responseJSON = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'secret-key': secretKey,
+      },
+    });
+
+    const response = await responseJSON.json();
+    if (response?.errors) {
+      customLog.changeAndThrow(
+        'Invalid Parameters for Workflow: ',
+        ...response?.errors,
+      );
+    } else {
+      const workflowConfig = response?.data;
 
-      const dirPath = getValueFromArgs(args, Key.WORKFLOW);
-      const workflowName = dirPath.replace(/\//g, '__');
-      const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
+      const folderPath = path.resolve(dirPath);
+      fs.mkdirSync(folderPath, { recursive: true });
 
-      if (!secretKey) {
-        customLog.error(`Parameter secret is required`);
-        return;
-      }
+      const filePath = path.join(folderPath, 'workflow.json');
+      fs.writeFileSync(filePath, JSON.stringify(workflowConfig, null, 2));
 
-      if (!workflowName) {
-        customLog.error(`Parameter workflow is required`);
-        return;
-      }
+      customLog.success(`Workflow cloned successfully`);
+    }
+  }
 
-      const url = `${MSTATE_URL}/workflow/config/${workflowName}`;
-      const responseJSON = await fetch(url, {
-        method: 'GET',
-        headers: {
-          'Content-Type': 'application/json',
-          'secret-key': secretKey,
-        },
-      });
+  async resetCache() {
+    const args = process.argv;
 
-      const response = await responseJSON.json();
-      if (response?.errors) {
-        customLog.error('Invalid Parameters: ', response?.errors);
-      } else {
-        const workflowConfig = response?.data;
+    const dirPath = getValueFromArgs(args, Key.WORKFLOW);
+    const workflowName = dirPath.replace(/\//g, '__');
+    const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
 
-        const folderPath = path.resolve(dirPath);
-        fs.mkdirSync(folderPath, { recursive: true });
+    if (!secretKey) {
+      customLog.changeAndThrow(`Parameter secret is required`);
+      return;
+    }
 
-        const filePath = path.join(folderPath, 'workflow.json');
-        fs.writeFileSync(filePath, JSON.stringify(workflowConfig, null, 2));
+    if (!workflowName) {
+      customLog.changeAndThrow(`Parameter workflow is required`);
+      return;
+    }
 
-        customLog.success(`Workflow cloned successfully`);
-      }
-    } catch (error: any) {
-      customLog.error('Error in cloning workflow', error.message);
+    const url = `${MSTATE_URL}/cache/reset/${workflowName}`;
+    const responseJSON = await fetch(url, {
+      method: 'DELETE',
+      headers: {
+        'Content-Type': 'application/json',
+        'secret-key': secretKey,
+      },
+    });
+
+    const response = await responseJSON.json();
+    if (response?.errors) {
+      customLog.changeAndThrow(
+        'Invalid Parameters for Workflow: ',
+        ...response?.errors,
+      );
+    } else {
+      customLog.success(`Workflow updated successfully`);
     }
   }
 }

package/src/index.ts

@@ -6,69 +6,62 @@ import { actionHandler } from './handlers/action.handler';
 import { workflowHandler } from './handlers/workflow.handler';
 import { CmdAction } from './common/enum';
 import { mobiofficeHandler } from './handlers/mobioffice.handler';
-import { customLog } from './common/utils';
+import { customLog, hasFlag } from './common/utils';
 import { environmentHandler } from './handlers/environment.handler';
+import { companyHandler } from './handlers/company.handler';
+import { argv } from 'process';
+import { helpHandler } from './handlers/help.handler';
 
-const [action] = process.argv.slice(2);
+const [action] = argv.slice(2);
+(async function () {
+  switch (action as CmdAction) {
+    case CmdAction.VERSION:
+    case CmdAction.VERSION_FLAG:
+      console.log(`v${packageJSON.version}`);
+      break;
 
-switch (action as CmdAction) {
-  case CmdAction.VERSION:
-  case CmdAction.VERSION_FLAG:
-    console.log(`v${packageJSON.version}`);
-    break;
+    case CmdAction.LINK:
+    case CmdAction.UNLINK:
+      await mobiofficeHandler.linkToMobioffice(
+        action as CmdAction.LINK | CmdAction.UNLINK,
+      );
+      break;
 
-  case CmdAction.LINK:
-  case CmdAction.UNLINK:
-    mobiofficeHandler.linkToMobioffice(
-      action as CmdAction.LINK | CmdAction.UNLINK,
-    );
-    break;
-  case CmdAction.CLONE:
-    workflowHandler.cloneWorkflow().then(() => {
-      actionHandler.cloneActions();
-      environmentHandler.cloneEnvironments();
-    });
-    break;
-  case CmdAction.ADD:
-    workflowHandler.saveToDB();
-    break;
-  case CmdAction.PUSH:
-    workflowHandler.updateWorkflowToDB().then(() => {
-      actionHandler.saveToDB();
-      environmentHandler.saveToDB();
-    });
-    break;
-  case CmdAction.HELP:
-  case CmdAction.HELP_FLAG:
-    console.log('\n\nUsage: mstate [cmd] [parameter]="[value]"\n');
+    case CmdAction.USER:
+      if (hasFlag(argv, '-d')) companyHandler.revokePermission();
+      else companyHandler.addToken();
+      break;
 
-    console.log('Commands:');
-    customLog.info(CmdAction.ADD, 'Add new workflow');
-    customLog.info(
-      CmdAction.CLONE,
-      'Clone workflow with actions and environments',
-    );
-    customLog.info(CmdAction.PUSH, 'Update the changes one in cloned workflow');
-    customLog.info(
-      CmdAction.LINK,
-      'add workflow and allow user to view workflow to mobioffice application',
-    );
-    customLog.info(
-      CmdAction.UNLINK,
-      'add workflow and remove user to view workflow to mobioffice application',
-    );
-    customLog.info(
-      [CmdAction.VERSION_FLAG, CmdAction.VERSION].toString(),
-      'add workflow and remove user to view workflow to mobioffice application',
-    );
-    break;
-  default:
-    customLog.error(
-      `${action ? 'Invalid' : 'Missing'} script: ${action ?? ''}`,
-    );
-    console.log(
-      `use 'mstate ${CmdAction.HELP_FLAG}, ${CmdAction.HELP}' for getting allowed action`,
-    );
-}
+    case CmdAction.CLONE:
+      await workflowHandler.cloneWorkflow();
+      await actionHandler.cloneActions();
+      await environmentHandler.cloneEnvironments();
+      break;
+    case CmdAction.ADD:
+      await workflowHandler.saveToDB();
+      break;
+    case CmdAction.PUSH:
+      await workflowHandler.updateWorkflowToDB();
+      await actionHandler.saveToDB();
+      await environmentHandler.saveToDB();
+      await workflowHandler.resetCache();
+      break;
+    case CmdAction.HELP:
+    case CmdAction.HELP_FLAG:
+      helpHandler.logCommandInfo();
+      break;
 
+    default:
+      customLog.changeAndThrow(
+        `${action ? 'Invalid' : 'Missing'} script: ${action ?? ''}`,
+      );
+      console.log(
+        `use 'mstate ${CmdAction.HELP_FLAG}, ${CmdAction.HELP}' for getting allowed action`,
+      );
+  }
+})().catch((error: any) => {
+  if (hasFlag(argv, CmdAction.HELP) || hasFlag(argv, CmdAction.HELP_FLAG)) {
+    helpHandler.logActionInfo(action as CmdAction);
+  } else customLog.error(error.message);
+});
 console.log('');