zudello-execute-local 1.0.37 → 1.1.0

package/index.js

@@ -1,338 +1,74 @@
 #!/usr/bin/env node
 
-const yargs = require("yargs");
-const dotenv = require("dotenv");
-const fs = require("fs");
-const path = require("path");
-const { NodeVM, makeResolverFromLegacyOptions } = require("vm2");
+const yargs = require('yargs')
+const dotenv = require('dotenv')
+const fs = require('fs')
+const path = require('path')
+const { runScript } = require('./src/utils/nodeVM')
 
 const argv = yargs
-	.option("script", {
-		alias: "s",
-		description: "Path to the script file",
-		type: "string",
-		demandOption: true,
-	})
-	.option("env", {
-		alias: "e",
-		description: "Path to the .env file",
-		type: "string",
-		demandOption: true,
-	})
-	.option("handlerName", {
-		alias: "hn",
-		description: "Handler function name",
-		type: "string",
-		default: "handle",
-	})
-	.option("data", {
-		alias: "d",
-		description:
-			"Provided data that are passed to the script handler function (should be in JSON format)",
-		type: "string",
-		default: "{}",
-	})
-	.option("loggerMode", {
-		alias: "lm",
-		description:
-			"Logger Mode",
-		type: "string",
-		default: "PRODUCTION",
-	})
-	.help()
-	.alias("help", "h").argv;
-
-dotenv.config({ path: argv.env });
+  .option('script', {
+    alias: 's',
+    description: 'Path to the script file',
+    type: 'string',
+    demandOption: true,
+  })
+  .option('env', {
+    alias: 'e',
+    description: 'Path to the .env file',
+    type: 'string',
+    demandOption: true,
+  })
+  .option('handlerName', {
+    alias: 'hn',
+    description: 'Handler function name',
+    type: 'string',
+    default: 'handle',
+  })
+  .option('data', {
+    alias: 'd',
+    description:
+      'Provided data that are passed to the script handler function (should be in JSON format)',
+    type: 'string',
+    default: '{}',
+  })
+  .option('loggerMode', {
+    alias: 'lm',
+    description:
+      'Logger Mode',
+    type: 'string',
+    default: 'PRODUCTION',
+  })
+  .help()
+  .alias('help', 'h').argv
+
+dotenv.config({ path: argv.env })
 
 const init = async () => {
-	let data = {};
-	let scriptContent = "";
-
-	console.log(argv);
-
-	try {
-		data = JSON.parse(argv.data);
-	} catch (err) {
-		console.error("Error: Invalid JSON provided in --data");
-		process.exit(1);
-	}
-
-	const scriptPath = path.resolve(argv.script);
-
-	try {
-		scriptContent = fs.readFileSync(scriptPath, "utf8");
-	} catch (err) {
-		console.error(`Error: Unable to read script file at ${scriptPath}`);
-		console.error(err.message);
-		process.exit(1);
-	}
-
-	await runScript(argv.handlerName, scriptContent, data, argv.loggerMode);
-};
-
-const initNodeVM = () => {
-	return new NodeVM({
-		console: "inherit",
-		sandbox: {
-			process,
-		},
-		require: makeResolverFromLegacyOptions({
-			external: {
-				modules: [
-					"lodash",
-					"performance-now",
-					"moment",
-					"moment-timezone",
-					"he",
-					"zudello-integration-sdk",
-				],
-			},
-			builtin: ["https"],
-			root: path.resolve(__dirname),
-			import: [
-				"lodash",
-				"performance-now",
-				"moment",
-				"moment-timezone",
-				"he",
-				"zudello-integration-sdk",
-			],
-			mock: {
-				fs: {
-					readFileSync() {
-						return "Nice try!";
-					},
-				},
-			},
-		}),
-	});
-};
-
-const runScript = async (handler, source, object, loggerMode) => {
-	const nodeVM = initNodeVM();
-
-	const authData = {
-		team_uuid: process.env.AUTH_TEAM_UUID,
-		jwt_token: process.env.AUTH_JWT_TOKEN,
-		organization_uuid: process.env.AUTH_ORGANIZATION_UUID,
-		api_url: process.env.AUTH_API_URL,
-		api_version: process.env.AUTH_API_VERSION,
-		external_api_url: process.env.AUTH_EXTERNAL_API_URL,
-		auth_api_url: process.env.AUTH_AUTH_API_URL
-	};
-
-	const externalIntegrationName = process.env.EXTERNAL_INTEGRATION_NAME;
-	const externalConnectionUUID = process.env.EXTERNAL_CONNECTION_UUID;
-
-	const triggerAuthenticate = `
-    const auth = new Auth({
-      teamUUID: '${authData.team_uuid}',
-      token: '${authData.jwt_token}'
-    })
-    await auth.authenticate()
-  `;
-
-	const triggerZudello = `
-		const Zudello = new ZudelloSDK(auth, '${authData.organization_uuid}', '${authData.api_url}', '${authData.api_version}', logger)
-		const ZudelloAuth = new ZudelloAuthSDK(auth, '${authData.organization_uuid}', '${authData.auth_api_url}', '${authData.api_version}', logger)
-	`;
-
-	let triggerExternal = "";
-
-	if (externalIntegrationName && externalConnectionUUID) {
-		switch (externalIntegrationName) {
-			case "netsuite":
-				triggerExternal = `
-          const Netsuite = new NetsuiteSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-          const NetsuiteSOAP = new NetsuiteSoapSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-        `;
-				break;
-			case "intacct":
-				triggerExternal = `
-          const Intacct = new IntacctSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-        `;
-				break;
-			case "bc":
-				triggerExternal = `
-          const BC = new BusinessCentralSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-        `;
-				break;
-			case "zenoti":
-				triggerExternal = `
-          const Zenoti = new ZenotiSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-        `;
-				break;
-			case "dear":
-				triggerExternal = `
-          const Dear = new DearSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-        `;
-				break;
-			case "nexvia":
-				triggerExternal = `
-          const Nexvia = new NexviaSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-        `;
-				break;
-			case "fo":
-				triggerExternal = `
-          const FO = new FoSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-        `;
-				break;
-			case "retailExpress":
-				triggerExternal = `
-          const RetailExpress = new RetailExpressSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-        `;
-				break;
-			case "myobAcumatica":
-				triggerExternal = `
-          const MYOBAcumatica = new MYOBAcumaticaSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-        `;
-				break;
-			case "sybiz":
-				triggerExternal = `
-          const Sybiz = new SybizSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-        `;
-				break;
-			case "xero":
-				triggerExternal = `
-          const Xero = new XeroSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-        `;
-				break;
-			case "jobready":
-				triggerExternal = `
-          const JobReady = new JobReadySDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-        `;
-				break;
-		case "x3":
-					triggerExternal = `
-			  const X3 = new X3SDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-			`;
-					break;
-		case "navision":
-			triggerExternal = `
-		const Navision = new NavisionSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-	`;
-			break;
-		case "myobAccountRight":
-			triggerExternal = `
-		const MYOBAccountRight = new MYOBAccountRightSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-	`;
-			break;
-			case "sunSystems":
-				triggerExternal = `
-			const SunSystems = new SunSystemsSDK(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
-		`;
-				break;
-		}
-	}
-
-	let scriptFunction = nodeVM.run(
-		`module.exports = async function(callback) {
-    try {
-      const {
-        Auth,
-        ZudelloSDK,
-		ZudelloAuthSDK,
-        NetsuiteSDK,
-        NetsuiteSoapSDK,
-        IntacctSDK,
-		X3SDK,
-        BusinessCentralSDK,
-        ZenotiSDK,
-        DearSDK,
-        NexviaSDK,
-        FoSDK,
-        RetailExpressSDK,
-        MYOBAcumaticaSDK,
-		MYOBAccountRightSDK,
-        SybizSDK,
-		SunSystemsSDK,
-		NavisionSDK,
-        XeroSDK,
-        JobReadySDK,
-        Logger,
-        Metadata,
-        Tags,
-        Trigger,
-        Properties,
-        MiscHelper,
-        ModelHelper,
-        DatasetHelper,
-        S3Client
-      } = require('zudello-integration-sdk')
-      const _ = require('lodash')
-      const now = require('performance-now')
-      const moment = require('moment-timezone')
-      const he = require('he')
-
-      const logger = new Logger('${loggerMode}')
-      const metadata = new Metadata()
-      const properties = new Properties()
-      const tags = new Tags()
-      const misc = new MiscHelper()
-
-      ${triggerAuthenticate}
-      ${triggerZudello}
-      ${triggerExternal}
-
-      let Model
-      let Dataset
-
-      if (typeof Zudello !== 'undefined') {
-        Model = new ModelHelper(Zudello, logger)
-        Dataset = new DatasetHelper(Zudello, logger)
-      }
-
-      let triggerNode
-
-      if (auth) {
-        triggerNode = new Trigger(auth.getApiInstance(), auth.teamUUID);
-      }
-
-      ${source}
-
-      const startTime = now()
-
-      let result = null
-      let status = 'success'
-      let error = ''
-
-      try {
-        result = await ${handler}(${JSON.stringify(object)})
-      } catch (e) {
-        logger.error('Script Failed', e)
-        status = 'failed'
-        error = e.message
-      }
-
-      logger.info('status', status)
+  let data = {}
+  let scriptContent = ''
 
-      if (error) {
-        logger.info('error', error)
-      }
+  try {
+    data = JSON.parse(argv.data)
+  } catch (err) {
+    console.error('Error: Invalid JSON provided in --data')
+    process.exit(1)
+  }
 
-      const endTime = now()
-      const duration = endTime - startTime
+  const scriptPath = path.resolve(argv.script)
 
-      logger.info('duration', duration)
+  try {
+    scriptContent = fs.readFileSync(scriptPath, 'utf8')
+  } catch (err) {
+    console.error(`Error: Unable to read script file at ${scriptPath}`)
+    console.error(err.message)
+    process.exit(1)
+  }
 
-      callback(null, result)
-    } catch (error) {
-      callback(error)
-    }
-  }`,
-		path.resolve(__dirname, "index.js")
-	);
+  const dirNamePath = path.resolve(__dirname)
+  const dirNameFilePath = path.resolve(__dirname, 'index.js')
 
-	return new Promise((resolve, reject) => {
-		scriptFunction((err, response) => {
-			if (err) {
-				console.error(err);
-				reject(new Error(`Error executing script: ${err.message}`));
-			} else {
-				resolve(response);
-			}
-		});
-	});
-};
+  await runScript(argv.handlerName, scriptContent, data, argv.loggerMode, dirNamePath, dirNameFilePath)
+}
 
-init();
+init()

package/package.json

@@ -1,25 +1,25 @@
 {
-	"name": "zudello-execute-local",
-	"version": "1.0.37",
-	"description": "Zudello Execute tool for local runs",
-	"main": "index.js",
-	"bin": {
-		"zexec": "./index.js"
-	},
-	"scripts": {},
-	"author": "Zudello",
-	"license": "ISC",
-	"dependencies": {
-		"dotenv": "^16.3.1",
-		"fs": "^0.0.1-security",
-		"he": "^1.2.0",
-		"lodash": "^4.17.21",
-		"moment": "^2.30.1",
-		"moment-timezone": "^0.5.46",
-		"path": "^0.12.7",
-		"performance-now": "^2.1.0",
-		"vm2": "^3.9.19",
-		"yargs": "^17.7.2",
-		"zudello-integration-sdk": "^1.0.43"
-	}
+  "name": "zudello-execute-local",
+  "version": "1.1.0",
+  "description": "Zudello Execute tool for local runs",
+  "main": "index.js",
+  "bin": {
+    "zexec": "./index.js"
+  },
+  "scripts": {},
+  "author": "Zudello",
+  "license": "ISC",
+  "dependencies": {
+    "dotenv": "^16.3.1",
+    "fs": "^0.0.1-security",
+    "he": "^1.2.0",
+    "lodash": "^4.17.21",
+    "moment": "^2.30.1",
+    "moment-timezone": "^0.5.46",
+    "path": "^0.12.7",
+    "performance-now": "^2.1.0",
+    "vm2": "^3.9.19",
+    "yargs": "^17.7.2",
+    "zudello-integration-sdk": "^1.0.43"
+  }
 }

package/src/utils/nodeVM.js

@@ -0,0 +1,272 @@
+const { NodeVM, makeResolverFromLegacyOptions } = require('vm2')
+
+const connectionSdkMapping = {
+  netsuite: [{
+    variable: 'Netsuite',
+    class: 'NetsuiteSDK',
+    isExternal: true
+  }, {
+    variable: 'NetsuiteSOAP',
+    class: 'NetsuiteSoapSDK',
+    isExternal: true
+  }],
+  intacct: [{
+    variable: 'Intacct',
+    class: 'IntacctSDK',
+    isExternal: true
+  }],
+  xero: [{
+    variable: 'Xero',
+    class: 'XeroSDK',
+    isExternal: true
+  }],
+  bc: [{
+    variable: 'BC',
+    class: 'BusinessCentralSDK',
+    isExternal: true
+  }],
+  zenoti: [{
+    variable: 'Zenoti',
+    class: 'ZenotiSDK',
+    isExternal: true
+  }],
+  dear: [{
+    variable: 'Dear',
+    class: 'DearSDK',
+    isExternal: true
+  }],
+  nexvia: [{
+    variable: 'Nexvia',
+    class: 'NexviaSDK',
+    isExternal: true
+  }],
+  fo: [{
+    variable: 'FO',
+    class: 'FoSDK',
+    isExternal: true
+  }],
+  retailExpress: [{
+    variable: 'RetailExpress',
+    class: 'RetailExpressSDK',
+    isExternal: true
+  }],
+  myobAcumatica: [{
+    variable: 'MYOBAcumatica',
+    class: 'MYOBAcumaticaSDK',
+    isExternal: true
+  }],
+  sybiz: [{
+    variable: 'Sybiz',
+    class: 'SybizSDK',
+    isExternal: true
+  }],
+  jobready: [{
+    variable: 'JobReady',
+    class: 'JobReadySDK',
+    isExternal: true
+  }],
+  sapb1: [{
+    variable: 'SapB1',
+    class: 'SAPB1SDK',
+    isExternal: true
+  }],
+  gp: [{
+    variable: 'GP',
+    class: 'GPSDK',
+    isExternal: true
+  }],
+  x3: [{
+    variable: 'X3',
+    class: 'X3SDK',
+    isExternal: true
+  }],
+  navision: [{
+    variable: 'Navision',
+    class: 'NavisionSDK',
+    isExternal: true
+  }],
+  myobAccountRight: [{
+    variable: 'MYOBAccountRight',
+    class: 'MYOBAccountRightSDK',
+    isExternal: true
+  }],
+  sunSystems: [{
+    variable: 'SunSystems',
+    class: 'SunSystemsSDK',
+    isExternal: true
+  }]
+}
+
+const initiateNodeVM = (dirNamePath) => {
+  return new NodeVM({
+    console: 'inherit',
+    sandbox: {
+      process,
+    },
+    require: makeResolverFromLegacyOptions({
+      external: {
+        modules: [
+          'lodash',
+          'performance-now',
+          'moment',
+          'moment-timezone',
+          'he',
+          'zudello-integration-sdk',
+        ],
+      },
+      builtin: ['https'],
+      root: dirNamePath,
+      import: [
+        'lodash',
+        'performance-now',
+        'moment',
+        'moment-timezone',
+        'he',
+        'zudello-integration-sdk',
+      ],
+      mock: {
+        fs: {
+          readFileSync() {
+            return 'Nice try!'
+          },
+        },
+      },
+    }),
+  })
+}
+
+const runScript = async (handler, source, object, loggerMode, dirNamePath, dirNameFilePath) => {
+  const nodeVM = initiateNodeVM(dirNamePath)
+
+  console.log(process.env)
+
+  const authData = {
+    team_uuid: process.env.AUTH_TEAM_UUID,
+    jwt_token: process.env.AUTH_JWT_TOKEN,
+    organization_uuid: process.env.AUTH_ORGANIZATION_UUID,
+    api_url: process.env.AUTH_API_URL,
+    api_version: process.env.AUTH_API_VERSION,
+    external_api_url: process.env.AUTH_EXTERNAL_API_URL,
+    auth_api_url: process.env.AUTH_AUTH_API_URL
+  }
+
+  console.log(authData)
+  console.log(dirNamePath)
+  console.log(dirNameFilePath)
+
+  const externalIntegrationName = process.env.EXTERNAL_INTEGRATION_NAME
+  const externalConnectionUUID = process.env.EXTERNAL_CONNECTION_UUID
+
+  const classesInUse = [
+    'Logger', 'Metadata', 'Tags', 'Trigger', 'Properties', 'MiscHelper',
+    'ModelHelper', 'DatasetHelper', 'S3Client', 'Auth', 'ZudelloSDK', 'ZudelloAuthSDK'
+  ]
+
+  const initAuth = `
+    const auth = new Auth({
+      teamUUID: '${authData.team_uuid}',
+      token: '${authData.jwt_token}'
+    })
+    await auth.authenticate()
+  `
+  const initZudello = `
+    const Zudello = new ZudelloSDK(auth, '${authData.organization_uuid}', '${authData.api_url}', '${authData.api_version}', logger)
+    const ZudelloAuth = new ZudelloAuthSDK(auth, '${authData.organization_uuid}', '${authData.auth_api_url}', '${authData.api_version}', logger)
+  `
+
+  let initExternalConnections = ''
+
+  if (connectionSdkMapping[externalIntegrationName]) {
+    const connectionInfoArray = connectionSdkMapping[externalIntegrationName]
+
+    connectionInfoArray.forEach(info => {
+      classesInUse.push(info.class)
+      initExternalConnections += `
+        const ${info.variable} = new ${info.class}(auth, '${externalConnectionUUID}', '${authData.organization_uuid}', '${authData.external_api_url}', '${authData.api_version}', logger)
+      `
+    })
+  }
+
+  let scriptFunction = nodeVM.run(
+    `module.exports = async function(callback) {
+      try {
+        const { ${classesInUse.join(',')} } = require('zudello-integration-sdk')
+        const _ = require('lodash')
+        const now = require('performance-now')
+        const moment = require('moment-timezone')
+        const he = require('he')
+
+        const logger = new Logger('${loggerMode}')
+        const metadata = new Metadata()
+        const properties = new Properties()
+        const tags = new Tags()
+        const misc = new MiscHelper()
+
+        ${initAuth}
+        ${initZudello}
+        ${initExternalConnections}
+
+        let Model
+        let Dataset
+
+        if (typeof Zudello !== 'undefined') {
+          Model = new ModelHelper(Zudello, logger)
+          Dataset = new DatasetHelper(Zudello, logger)
+        }
+
+        let triggerNode
+
+        if (auth) {
+          triggerNode = new Trigger(auth.getApiInstance(), auth.teamUUID)
+        }
+
+        ${source}
+
+        const startTime = now()
+
+        let result = null
+        let status = 'success'
+        let error = ''
+
+        try {
+          result = await ${handler}(${JSON.stringify(object)})
+        } catch (e) {
+          logger.error('Script Failed', e)
+          status = 'failed'
+          error = e.message
+        }
+
+        logger.info('status', status)
+
+        if (error) {
+          logger.info('error', error)
+        }
+
+        const endTime = now()
+        const duration = endTime - startTime
+
+        logger.info('duration', duration)
+
+        callback(null, result)
+      } catch (error) {
+        callback(error)
+      }
+    }`,
+    dirNameFilePath
+  )
+
+  return new Promise((resolve, reject) => {
+    scriptFunction((err, response) => {
+      if (err) {
+        console.error(err)
+        reject(new Error(`Error executing script: ${err.message}`))
+      } else {
+        resolve(response)
+      }
+    })
+  })
+}
+
+module.exports = {
+  runScript
+}