mstate-cli 0.0.2 → 0.0.9

package/dist/index.js

@@ -1,21 +1,44 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const workflow_action_1 = require("./actions/workflow.action");
+const action_handler_1 = require("./handlers/action.handler");
+const workflow_handler_1 = require("./handlers/workflow.handler");
 const enum_1 = require("./common/enum");
-const [action, ...params] = process.argv.slice(2);
+const mobioffice_handler_1 = require("./handlers/mobioffice.handler");
+const utils_1 = require("./common/utils");
+const environment_handler_1 = require("./handlers/environment.handler");
+const [action] = process.argv.slice(2);
 switch (action) {
     case enum_1.CmdAction.LINK:
+    case enum_1.CmdAction.UNLINK:
+        mobioffice_handler_1.mobiofficeHandler.linkToMobioffice(action);
         break;
     case enum_1.CmdAction.CLONE:
-        workflow_action_1.workflowAction.cloneWorkflow(params);
+        workflow_handler_1.workflowHandler.cloneWorkflow().then(() => {
+            action_handler_1.actionHandler.cloneActions();
+            environment_handler_1.environmentHandler.cloneEnvironments();
+        });
         break;
     case enum_1.CmdAction.ADD:
-        workflow_action_1.workflowAction.saveToDB(params);
+        workflow_handler_1.workflowHandler.saveToDB();
         break;
-    case enum_1.CmdAction.UPDATE:
-        workflow_action_1.workflowAction.updateWorkflowToDB(params);
+    case enum_1.CmdAction.PUSH:
+        workflow_handler_1.workflowHandler.updateWorkflowToDB().then(() => {
+            action_handler_1.actionHandler.saveToDB();
+            environment_handler_1.environmentHandler.saveToDB();
+        });
+        break;
+    case enum_1.CmdAction.HELP:
+    case enum_1.CmdAction.HELP_FLAG:
+        console.log('\n\nUsage: mstate [cmd] [parameter]="[value]"\n');
+        console.log('Commands:');
+        utils_1.customLog.info(enum_1.CmdAction.ADD, 'Add new workflow');
+        utils_1.customLog.info(enum_1.CmdAction.CLONE, 'Clone workflow with actions and environments');
+        utils_1.customLog.info(enum_1.CmdAction.PUSH, 'Update the changes one in cloned workflow');
+        utils_1.customLog.info(enum_1.CmdAction.LINK, 'add workflow and allow user to view workflow to mobioffice application');
+        utils_1.customLog.info(enum_1.CmdAction.UNLINK, 'add workflow and remove user to view workflow to mobioffice application');
         break;
     default:
-        console.error(`Mstate`, 'error', `Missing script: "${action}"`);
+        utils_1.customLog.error(`Invalid script: "${action}"`);
+        console.log('use `mstate help, -h` for getting allowed action');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mstate-cli",
-  "version": "0.0.2",
+  "version": "0.0.9",
   "main": "index.js",
   "bin": {
     "mstate": "./dist/index.js"

package/src/common/constant.ts

@@ -1,2 +1,3 @@
-export const MSTATE_URL = 'https://dev.mstate.mobioffice.io/api';
-// export const MSTATE_URL = "https://api.mstate.mobioffice.io/api";
+// export const MSTATE_URL = 'https://dev.mstate.mobioffice.io/api';
+export const MSTATE_URL = 'https://api.mstate.mobioffice.io/api';
+export const MOBIOFFICE_URL = 'https://server.mobioffice.io/api';

package/src/common/enum.ts

@@ -1,6 +1,9 @@
 export enum CmdAction {
   LINK = 'link',
+  UNLINK = 'unlink',
   ADD = 'add',
   CLONE = 'clone',
-  UPDATE = 'update',
+  PUSH = 'push',
+  HELP = 'help',
+  HELP_FLAG = '-h',
 }

package/src/common/utils.ts

@@ -0,0 +1,27 @@
+export function getValueFromArgs(args: string[], key: string) {
+  return args.find((str) => str.includes(key))?.replace(key, '') ?? '';
+}
+
+export const customLog = {
+  error(...message: string[]) {
+    const RED_COLOR = '\x1b[31m'; // ANSI code for red
+    const RESET_COLOR = '\x1b[0m'; // ANSI code to reset to default color
+
+    console.error(`${RED_COLOR}[MSTATE][ERROR] ${RESET_COLOR}`, ...message);
+  },
+
+  success(...message: string[]) {
+    const GREEN_COLOR = '\x1b[32m'; // ANSI code for green
+    const RESET_COLOR = '\x1b[0m'; // ANSI code to reset to default color
+
+    console.log(`${GREEN_COLOR}[MSTATE] ${RESET_COLOR}`, ...message);
+  },
+  info(key: string, desc: string) {
+    const optionPadding = 30; // Define spacing width for the option column
+    const descriptionPadding = 60; // Define spacing width for the description column
+    console.log(
+      ' ',
+      key.padEnd(optionPadding) + desc.padEnd(descriptionPadding),
+    );
+  },
+};

package/src/handlers/action.handler.ts

@@ -0,0 +1,126 @@
+import * as fs from 'fs';
+import path from 'path';
+import { MSTATE_URL } from '../common/constant';
+import { customLog, getValueFromArgs } from '../common/utils';
+
+enum Key {
+  WORKFLOW = 'workflow=',
+  SECRET_KEY = 'secret=',
+}
+
+class ActionHandler {
+  constructor() {}
+
+  async cloneActions() {
+    try {
+      const args = process.argv;
+      const workflowName = getValueFromArgs(args, Key.WORKFLOW);
+      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 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 actionConfigs = response?.data;
+
+          const folderPath = path.resolve(workflowName, 'actions');
+          fs.mkdirSync(folderPath, { recursive: true });
+
+          actionConfigs.forEach((config: ActionConfig) => {
+            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 in cloning action', error.message);
+      }
+    } catch (error: any) {
+      customLog.error('Error in cloning action', error.message);
+    }
+  }
+
+  async saveToDB() {
+    try {
+      const args = process.argv;
+
+      const workflowName = getValueFromArgs(args, Key.WORKFLOW);
+      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 folderPath = path.resolve(workflowName, 'actions');
+
+      // 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);
+          }
+        });
+      });
+    } catch (error: any) {
+      customLog.error(error.message);
+    }
+  }
+}
+
+export const actionHandler = new ActionHandler();

package/src/handlers/environment.handler.ts

@@ -0,0 +1,108 @@
+import * as fs from 'fs';
+import path from 'path';
+import { MSTATE_URL } from '../common/constant';
+import { customLog, getValueFromArgs } from '../common/utils';
+
+enum Key {
+  WORKFLOW = 'workflow=',
+  SECRET_KEY = 'secret=',
+}
+
+class EnvironmentHandler {
+  constructor() {}
+
+  async cloneEnvironments() {
+    try {
+      const args = process.argv;
+      const workflowName = getValueFromArgs(args, Key.WORKFLOW);
+      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}/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(workflowName, '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);
+    }
+  }
+
+  async saveToDB() {
+    try {
+      const args = process.argv;
+
+      const workflowName = getValueFromArgs(args, Key.WORKFLOW);
+      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 filePath = path.resolve(workflowName, 'environment.json');
+
+      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);
+      }
+    } catch (error) {
+      customLog.error('Something went wrong');
+    }
+  }
+}
+
+export const environmentHandler = new EnvironmentHandler();

package/src/handlers/mobioffice.handler.ts

@@ -0,0 +1,72 @@
+import { MOBIOFFICE_URL } from '../common/constant';
+import { CmdAction } from '../common/enum';
+import { customLog, getValueFromArgs } from '../common/utils';
+
+enum Key {
+  WORKFLOW = 'workflow=',
+  SECRET_KEY = 'secret=',
+  COMPANY_ID = 'company=',
+  USER_ID = 'user=',
+}
+
+class MobiofficeHandler {
+  constructor() {}
+
+  async linkToMobioffice(action: CmdAction.LINK | CmdAction.UNLINK) {
+    try {
+      const args = process.argv;
+
+      const workflowPath = getValueFromArgs(args, Key.WORKFLOW);
+      const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
+      const companyID = getValueFromArgs(args, Key.COMPANY_ID);
+      const user = getValueFromArgs(args, Key.USER_ID);
+
+      if (!workflowPath) {
+        customLog.error(`Parameter workflow is required`);
+        return;
+      }
+
+      if (!secretKey) {
+        customLog.error(`Parameter secret is required`);
+        return;
+      }
+
+      if (!companyID) {
+        customLog.error(`Parameter company is required`);
+        return;
+      }
+
+      if (!user) {
+        customLog.error(`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: workflowPath,
+          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);
+    }
+  }
+}
+
+export const mobiofficeHandler = new MobiofficeHandler();

package/src/handlers/workflow.handler.ts

@@ -0,0 +1,160 @@
+import * as fs from 'fs';
+import path from 'path';
+import { MSTATE_URL } from '../common/constant';
+import { customLog, getValueFromArgs } from '../common/utils';
+
+enum Key {
+  PATH = 'path=',
+  FILE = 'file=',
+  SECRET_KEY = 'secret=',
+  WORKFLOW = 'workflow=',
+}
+
+class WorkflowHandler {
+  constructor() {}
+
+  async saveToDB() {
+    try {
+      const args = process.argv;
+
+      const workflowPath = getValueFromArgs(args, Key.PATH);
+      const file = getValueFromArgs(args, Key.FILE);
+      const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
+
+      const filePath = path.resolve(file);
+      const workflowJSON = fs.readFileSync(filePath, 'utf8');
+
+      if (!file) {
+        customLog.error(`Parameter file is required`);
+        return;
+      }
+
+      if (!secretKey) {
+        customLog.error(`Parameter secret is required`);
+        return;
+      }
+
+      let query = '';
+      if (workflowPath) {
+        query += `path=${workflowPath}`;
+      }
+
+      if (query.length) {
+        query = '?' + query;
+      }
+
+      const url = `${MSTATE_URL}/workflow/config/new${query}`;
+      const responseJSON = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'secret-key': secretKey,
+          'Content-Type': 'application/json',
+        },
+        body: workflowJSON,
+      });
+
+      const response = await responseJSON.json();
+      if (response?.errors) {
+        customLog.error('Invalid Parameters: ', response?.errors);
+      } else {
+        customLog.success('Workflow Added successfully', response?.data);
+      }
+    } catch (error: any) {
+      customLog.error(error.message);
+    }
+  }
+
+  async updateWorkflowToDB() {
+    try {
+      const args = process.argv;
+
+      const workflow = getValueFromArgs(args, Key.WORKFLOW);
+      const secretKey = getValueFromArgs(args, Key.SECRET_KEY);
+
+      if (!secretKey) {
+        customLog.error(`Parameter secret is required`);
+        return;
+      }
+
+      if (!workflow) {
+        customLog.error(`Parameter workflow is required`);
+        return;
+      }
+
+      const folderPath = path.resolve(workflow);
+      const filePath = path.join(folderPath, 'workflow.json');
+
+      const workflowJSON = fs.readFileSync(filePath, 'utf8');
+
+      let query = `?workflow=${workflow}`;
+
+      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.error('Invalid Parameters: ', response?.errors);
+      } else {
+        customLog.success('Workflow Uploaded successfully \n', response?.data);
+      }
+
+      return response;
+    } catch (error: any) {
+      customLog.error(error.message);
+    }
+  }
+
+  async cloneWorkflow() {
+    try {
+      const args = process.argv;
+
+      const workflowName = getValueFromArgs(args, Key.WORKFLOW);
+      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 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.error('Invalid Parameters: ', response?.errors);
+      } else {
+        const workflowConfig = response?.data;
+
+        const folderPath = path.resolve(workflowName);
+        fs.mkdirSync(folderPath, { recursive: true });
+
+        const filePath = path.join(folderPath, 'workflow.json');
+        fs.writeFileSync(filePath, JSON.stringify(workflowConfig, null, 2));
+
+        customLog.success(`Workflow "${workflowName}" is cloned successfully`);
+      }
+    } catch (error: any) {
+      customLog.error('Error in cloning workflow', error.message);
+    }
+  }
+}
+
+export const workflowHandler = new WorkflowHandler();

package/src/index.ts

@@ -1,23 +1,57 @@
 #!/usr/bin/env node
 
-import { workflowAction } from './actions/workflow.action';
+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 { environmentHandler } from './handlers/environment.handler';
 
-const [action, ...params] = process.argv.slice(2);
+const [action] = process.argv.slice(2);
 
 switch (action as CmdAction) {
   case CmdAction.LINK:
+  case CmdAction.UNLINK:
+    mobiofficeHandler.linkToMobioffice(
+      action as CmdAction.LINK | CmdAction.UNLINK,
+    );
     break;
   case CmdAction.CLONE:
-    workflowAction.cloneWorkflow(params);
+    workflowHandler.cloneWorkflow().then(() => {
+      actionHandler.cloneActions();
+      environmentHandler.cloneEnvironments();
+    });
     break;
   case CmdAction.ADD:
-    workflowAction.saveToDB(params);
+    workflowHandler.saveToDB();
     break;
-  case CmdAction.UPDATE:
-    workflowAction.updateWorkflowToDB(params);
+  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');
 
+    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',
+    );
+    break;
   default:
-    console.error(`Mstate`, 'error', `Missing script: "${action}"`);
+    customLog.error(`Invalid script: "${action}"`);
+    console.log('use `mstate help, -h` for getting allowed action');
 }

package/src/interface.d.ts

@@ -28,8 +28,8 @@ interface Action {
 }
 
 interface ActionConfig {
-  version: string;
   name: string;
+  version: string;
   meta?: unknown;
   type: 'MANUAL' | 'AUTO' | 'CHAINED';
   steps: Step[];