mstate-cli 0.1.3 → 0.1.6

package/src/handlers/action.handler.ts

@@ -12,115 +12,107 @@ class ActionHandler {
   constructor() {}
 
   async cloneActions() {
-    try {
-      const args = process.argv;
-      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 (!workflowName) {
-        customLog.error(`Parameter workflow is required`);
-        return;
-      }
-
-      try {
-        const url = `${MSTATE_URL}/action/config/all/?workflow=${workflowName}`;
+    const args = process.argv;
+    const dirPath = getValueFromArgs(args, Key.WORKFLOW);
+    const workflowName = dirPath.replace(/\//g, '__');
+    const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
+
+    if (!secretKey) {
+      customLog.changeAndThrow(`Parameter secret is required`);
+      return;
+    }
 
-        const responseJSON = await fetch(url, {
-          headers: {
-            'Content-Type': 'application/json',
-            'secret-key': secretKey,
-          },
-        });
+    if (!workflowName) {
+      customLog.changeAndThrow(`Parameter workflow is required`);
+      return;
+    }
 
-        const response = await responseJSON.json();
-        if (response?.errors) {
-          customLog.error('Invalid Parameters: ', response?.errors);
-        } else {
-          const actionConfigs = response?.data;
+    const url = `${MSTATE_URL}/action/config/all/?workflow=${workflowName}`;
 
-          const folderPath = path.resolve(dirPath, 'actions');
-          fs.mkdirSync(folderPath, { recursive: true });
+    const responseJSON = await fetch(url, {
+      headers: {
+        'Content-Type': 'application/json',
+        'secret-key': secretKey,
+      },
+    });
 
-          actionConfigs.forEach((config: ActionConfig) => {
-            const file = path.join(folderPath, `${config?.name}.json`);
-            fs.writeFileSync(file, JSON.stringify(config, null, 2));
+    const response = await responseJSON.json();
+    if (response?.errors) {
+      customLog.changeAndThrow(
+        'Invalid Parameters for Action: ',
+        ...response?.errors,
+      );
+    } else {
+      const actionConfigs = response?.data;
 
-            customLog.success(
-              'file created at',
-              folderPath,
-              `${config?.name}.json`,
-            );
-          });
+      const folderPath = path.resolve(dirPath, 'actions');
+      fs.mkdirSync(folderPath, { recursive: true });
+
+      actionConfigs.forEach((config: ActionConfig) => {
+        try {
+          const file = path.join(folderPath, `${config?.name}.json`);
+          fs.writeFileSync(file, JSON.stringify(config, null, 2));
+
+          customLog.success(
+            'file created at',
+            folderPath,
+            `${config?.name}.json`,
+          );
+        } catch (error: any) {
+          customLog.error(error.message);
         }
-      } catch (error: any) {
-        customLog.error('Error in cloning action', error.message);
-      }
-    } catch (error: any) {
-      customLog.error('Error in cloning action', error.message);
+      });
     }
   }
 
   async saveToDB() {
-    try {
-      const args = process.argv;
-      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 (!workflowName) {
-        customLog.error(`Parameter workflow is required`);
-        return;
-      }
+    const args = process.argv;
+    const dirPath = getValueFromArgs(args, Key.WORKFLOW);
+    const workflowName = dirPath.replace(/\//g, '__');
+    const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
+
+    if (!secretKey) {
+      customLog.changeAndThrow(`Parameter secret is required`);
+      return;
+    }
 
-      const folderPath = path.resolve(dirPath, 'actions');
+    if (!workflowName) {
+      customLog.changeAndThrow(`Parameter workflow is required`);
+      return;
+    }
+
+    const folderPath = path.resolve(dirPath, 'actions');
+
+    // loop to every folder to publish workflow
+    fs.readdir(folderPath, (err, files) => {
+      if (!files) return;
 
-      // loop to every folder to publish workflow
-      fs.readdir(folderPath, (err, files) => {
-        if (!files) return;
-
-        files.forEach(async (fileName) => {
-          try {
-            const filePath = path.join(folderPath, fileName);
-            const data = fs.readFileSync(filePath, 'utf8');
-
-            const url = `${MSTATE_URL}/action/config/?workflow=${workflowName}`;
-            const responseJSON = await fetch(url, {
-              method: 'PUT',
-              headers: {
-                'secret-key': secretKey,
-                'Content-Type': 'application/json',
-              },
-              body: data,
-            });
-            const response = await responseJSON.json();
-
-            if (response?.errors) {
-              customLog.error(
-                `Invalid Parameters for Action ${fileName}: `,
-                response?.errors,
-              );
-            } else {
-              customLog.success(`Action ${fileName} Updated successfully`);
-            }
-          } catch (error: any) {
-            customLog.error(error.message);
-          }
+      files.forEach(async (fileName) => {
+        const filePath = path.join(folderPath, fileName);
+        const data = fs.readFileSync(filePath, 'utf8');
+
+        const url = `${MSTATE_URL}/action/config/?workflow=${workflowName}`;
+        const responseJSON = await fetch(url, {
+          method: 'PUT',
+          headers: {
+            'secret-key': secretKey,
+            'Content-Type': 'application/json',
+          },
+          body: data,
         });
+        const response = await responseJSON.json();
+
+        const actionConfig = JSON.parse(data) as ActionConfig;
+        if (response?.errors) {
+          customLog.error(
+            `Invalid Parameters for Action ${actionConfig.name}: `,
+            ...response?.errors,
+          );
+        } else {
+          customLog.success(`Action ${actionConfig.name} Updated successfully`);
+        }
       });
-    } catch (error: any) {
-      customLog.error(error.message);
-    }
+    });
   }
 }
 

package/src/handlers/company.handler.ts

@@ -0,0 +1,108 @@
+import { MSTATE_URL } from '../common/constant';
+import { customLog, getValueFromArgs } from '../common/utils';
+
+enum Key {
+  PERMISSIONS = 'permissions=',
+  SECRET_KEY = 'secret=',
+  USER_ID = 'user=',
+}
+
+class CompanyHandler {
+  constructor() {}
+
+  async addToken() {
+    const args = process.argv;
+
+    const pString = getValueFromArgs(args, Key.PERMISSIONS).trim();
+    const permissions = pString.split(',');
+    const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
+    const user = getValueFromArgs(args, Key.USER_ID);
+
+    if (!pString.length) {
+      customLog.changeAndThrow(`Parameter permissions is required`);
+      return;
+    }
+
+    if (!secretKey) {
+      customLog.changeAndThrow(`Parameter secret is required`);
+      return;
+    }
+
+    if (!user) {
+      customLog.changeAndThrow(`Parameter user is required`);
+      return;
+    }
+
+    const url = `${MSTATE_URL}/company/permission`;
+    const responseJSON = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'secret-key': secretKey,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        user,
+        permissions,
+      }),
+    });
+
+    const response = await responseJSON.json();
+    if (response?.errors) {
+      customLog.changeAndThrow(
+        'Invalid Parameters for Company: ',
+        ...response?.errors,
+      );
+    } else {
+      customLog.success('Company updated successfully \n', response?.data);
+    }
+  }
+
+  async revokePermission() {
+    const args = process.argv;
+
+    const pString = getValueFromArgs(args, Key.PERMISSIONS);
+    const permissions = pString.split(',');
+    const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
+    const user = getValueFromArgs(args, Key.USER_ID);
+
+    if (!permissions.length) {
+      customLog.changeAndThrow(`Parameter permissions is required`);
+      return;
+    }
+
+    if (!secretKey) {
+      customLog.changeAndThrow(`Parameter secret is required`);
+      return;
+    }
+
+    if (!user) {
+      customLog.changeAndThrow(`Parameter user is required`);
+      return;
+    }
+
+    const url = `${MSTATE_URL}/company/permission`;
+    const responseJSON = await fetch(url, {
+      method: 'DELETE',
+      headers: {
+        'secret-key': secretKey,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        user,
+        permissions,
+      }),
+    });
+
+    const response = await responseJSON.json();
+    if (response?.errors) {
+      customLog.changeAndThrow(
+        'Invalid Parameters for Company: ',
+        ...response?.errors,
+      );
+    } else {
+      customLog.success('Company updated successfully \n', response?.data);
+    }
+  }
+}
+
+export const companyHandler = new CompanyHandler();

package/src/handlers/environment.handler.ts

@@ -12,97 +12,91 @@ class EnvironmentHandler {
   constructor() {}
 
   async cloneEnvironments() {
-    try {
-      const args = process.argv;
-      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;
-      }
+    const args = process.argv;
+    const dirPath = getValueFromArgs(args, Key.WORKFLOW);
+    const workflowName = dirPath.replace(/\//g, '__');
+    const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
+
+    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;
+    }
 
-      try {
-        const url = `${MSTATE_URL}/env/?workflow=${workflowName}`;
-
-        const responseJSON = await fetch(url, {
-          headers: {
-            'Content-Type': 'application/json',
-            'secret-key': secretKey,
-          },
-        });
-
-        const response = await responseJSON.json();
-        if (response?.errors) {
-          customLog.error('Invalid Parameters: ', response?.errors);
-        } else {
-          const config = response?.data;
-
-          const filePath = path.resolve(dirPath, 'environment.json');
-          fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
-        }
-      } catch (error: any) {
-        customLog.error('Error in cloning action', error.message);
-      }
-    } catch (error: any) {
-      customLog.error('Error in cloning action', error.message);
+    const url = `${MSTATE_URL}/env/?workflow=${workflowName}`;
+
+    const responseJSON = await fetch(url, {
+      headers: {
+        'Content-Type': 'application/json',
+        'secret-key': secretKey,
+      },
+    });
+
+    const response = await responseJSON.json();
+    if (response?.errors) {
+      customLog.changeAndThrow(
+        'Invalid Parameters for Environment: ',
+        ...response?.errors,
+      );
+    } else {
+      const config = response?.data;
+
+      const filePath = path.resolve(dirPath, 'environment.json');
+      fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
     }
   }
 
   async saveToDB() {
-    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 filePath = path.resolve(dirPath, 'environment.json');
+    const filePath = path.resolve(dirPath, 'environment.json');
+
+    const data = fs.readFileSync(filePath, 'utf8');
+    const environments = JSON.parse(data);
 
-      const data = fs.readFileSync(filePath, 'utf8');
-      const environments = JSON.parse(data);
-
-      try {
-        const url = `${MSTATE_URL}/env`;
-        const responseJSON = await fetch(url, {
-          method: 'POST',
-          headers: {
-            'secret-key': secretKey,
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify({
-            workflow: workflowName,
-            env: environments,
-          }),
-        });
-
-        const response = await responseJSON.json();
-        if (response?.errors) {
-          customLog.error(`Updating environment:`, response?.errors);
-        } else {
-          customLog.success(`Environments Updated successfully`);
-        }
-      } catch (error: any) {
-        customLog.error(error.message);
+    try {
+      const url = `${MSTATE_URL}/env`;
+      const responseJSON = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'secret-key': secretKey,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          workflow: workflowName,
+          env: environments,
+        }),
+      });
+
+      const response = await responseJSON.json();
+      if (response?.errors) {
+        customLog.changeAndThrow(
+          `Invalid Parameters for Environment: `,
+          ...response?.errors,
+        );
+      } else {
+        customLog.success(`Environments Updated successfully`);
       }
-    } catch (error) {
-      customLog.error('Something went wrong');
+    } catch (error: any) {
+      customLog.changeAndThrow(error.message);
     }
   }
 }

package/src/handlers/help.handler.ts

@@ -0,0 +1,34 @@
+import { CmdAction } from '../common/enum';
+import { customLog } from '../common/utils';
+
+class HelpHandler {
+  logCommandInfo() {
+    console.log('\n\nUsage: mstate [cmd] [parameter]="[value]"\n');
+
+    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',
+    );
+  }
+
+  logActionInfo(action: CmdAction) {
+    console.log({ action });
+  }
+}
+
+export const helpHandler = new HelpHandler();

package/src/handlers/mobioffice.handler.ts

@@ -1,9 +1,10 @@
-import { MOBIOFFICE_URL } from '../common/constant';
+import { MOBIOFFICE_URL, MSTATE_URL } from '../common/constant';
 import { CmdAction } from '../common/enum';
 import { customLog, getValueFromArgs } from '../common/utils';
 
 enum Key {
   WORKFLOW = 'workflow=',
+  PERMISSIONS = 'permissions=',
   SECRET_KEY = 'secret=',
   COMPANY_ID = 'company=',
   USER_ID = 'user=',
@@ -13,59 +14,58 @@ class MobiofficeHandler {
   constructor() {}
 
   async linkToMobioffice(action: CmdAction.LINK | CmdAction.UNLINK) {
-    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 companyID = getValueFromArgs(args, Key.COMPANY_ID);
-      const user = getValueFromArgs(args, Key.USER_ID);
+    const dirPath = getValueFromArgs(args, Key.WORKFLOW);
+    const workflowName = dirPath.replace(/\//g, '__');
+    const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
+    const companyID = getValueFromArgs(args, Key.COMPANY_ID);
+    const user = getValueFromArgs(args, Key.USER_ID);
 
-      if (!workflowName) {
-        customLog.error(`Parameter workflow is required`);
-        return;
-      }
+    if (!workflowName) {
+      customLog.changeAndThrow(`Parameter workflow is required`);
+      return;
+    }
 
-      if (!secretKey) {
-        customLog.error(`Parameter secret is required`);
-        return;
-      }
+    if (!secretKey) {
+      customLog.changeAndThrow(`Parameter secret is required`);
+      return;
+    }
 
-      if (!companyID) {
-        customLog.error(`Parameter company is required`);
-        return;
-      }
+    if (!companyID) {
+      customLog.changeAndThrow(`Parameter company is required`);
+      return;
+    }
 
-      if (!user) {
-        customLog.error(`Parameter user is required`);
-        return;
-      }
+    if (!user) {
+      customLog.changeAndThrow(`Parameter user is required`);
+      return;
+    }
 
-      const url = `${MOBIOFFICE_URL}/Mstate/workFlow/user`;
-      const responseJSON = await fetch(url, {
-        method: 'POST',
-        headers: {
-          'secret-key': secretKey,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          action: action.toUpperCase(),
-          workflow: workflowName,
-          secret: secretKey,
-          companyID,
-          user,
-        }),
-      });
+    const url = `${MOBIOFFICE_URL}/Mstate/workFlow/user`;
+    const responseJSON = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'secret-key': secretKey,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        action: action.toUpperCase(),
+        workflow: workflowName,
+        secret: secretKey,
+        companyID,
+        user,
+      }),
+    });
 
-      const response = await responseJSON.json();
-      if (responseJSON.status >= 400) {
-        customLog.error('Invalid Parameters: ', responseJSON.statusText);
-      } else {
-        customLog.success('Workflow Added successfully', response?.message);
-      }
-    } catch (error: any) {
-      customLog.error(error.message);
+    const response = await responseJSON.json();
+    if (responseJSON.status >= 400) {
+      customLog.changeAndThrow(
+        'Invalid Parameters for Linking: ',
+        responseJSON.statusText,
+      );
+    } else {
+      customLog.success('Workflow Added successfully', response?.message);
     }
   }
 }