@things-factory/integration-base 7.0.1-rc.1 → 7.0.1-rc.11

package/server/engine/task/log.ts

@@ -1,5 +1,5 @@
 import { access, hasTemplateExpression } from '@things-factory/utils'
-import { VM } from 'vm2'
+import 'ses'
 import { TaskRegistry } from '../task-registry'
 import { InputStep } from '../../service/step/step-type'
 import { Context } from '../types'
@@ -10,23 +10,26 @@ async function Log(step: InputStep, { logger, data, variables, domain, user, lng
   } = step
 
   if (hasTemplateExpression(message)) {
-    const vm = new VM({
-      sandbox: {
-        domain,
-        user,
-        lng,
-        data,
-        variables
-      }
+    const compartment = new Compartment({
+      domain,
+      user,
+      lng,
+      data,
+      variables,
+      console
     })
 
-    message = vm.run('`' + message + '`')
+    try {
+      message = compartment.evaluate('`' + message + '`')
+    } catch (err) {
+      throw new Error(`Failed to evaluate message: ${err.message}`)
+    }
   }
 
   accessor = access(accessor, data)
 
   if (accessor) {
-    if (accessor !== 'string') {
+    if (typeof accessor !== 'string') {
       accessor = JSON.stringify(accessor, null, 2)
     }
     message += ': ' + accessor

package/server/engine/task/oracle-procedure.ts

@@ -1,15 +1,15 @@
-import { VM } from 'vm2'
 import { logger } from '@things-factory/env'
 import { access } from '@things-factory/utils'
 import { ConnectionManager } from '../connection-manager'
 import { TaskRegistry } from '../task-registry'
 import { InputStep } from '../../service/step/step-type'
 import { Context } from '../types'
+import 'ses'
 
 try {
   var oracledb = require('oracledb')
 } catch (err) {
-  logger.error('oracledb module loading failed')
+  logger.error('oracledb module loading failed', err)
 }
 
 type ProcedureParameterType = {
@@ -51,21 +51,27 @@ async function OracleProcedure(step: InputStep, context: Context) {
 
   var dbconnection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
 
-  const vm = new VM({
-    sandbox: {
-      domain,
-      user,
-      lng,
-      data,
-      variables
-    }
-  })
-
   if (!code) {
     throw 'procedure code not defined'
   }
 
-  code = vm.run('`' + code + '`')
+  const compartment = new Compartment({
+    domain,
+    user,
+    lng,
+    data,
+    variables,
+    console
+  })
+
+  let evalCode
+  try {
+    evalCode = compartment.evaluate('`' + code + '`')
+  } catch (err) {
+    throw new Error(`Failed to evaluate code: ${err.message}`)
+  }
+
+  code = evalCode
 
   const procedureParameters =
     parameters &&
@@ -79,13 +85,13 @@ async function OracleProcedure(step: InputStep, context: Context) {
 
       if (calculated !== undefined) {
         sum[name].val =
-          type == 'Date'
+          type === 'Date'
             ? new Date(calculated)
             : type == 'Number'
-            ? Number(calculated)
-            : type == 'String'
-            ? String(calculated)
-            : calculated
+              ? Number(calculated)
+              : type == 'String'
+                ? String(calculated)
+                : calculated
       }
 
       if (maxSize) {

package/server/engine/task/script.ts

@@ -1,34 +1,44 @@
 import { TaskRegistry } from '../task-registry'
-import { NodeVM } from 'vm2'
-
 import { InputStep } from '../../service/step/step-type'
 import { Context } from '../types'
+import 'ses'
 
 async function Script(step: InputStep, context: Context) {
-  var {
+  const {
     params: { script }
   } = step
 
   const { domain, user, data, variables, lng, logger } = context
 
-  const vm = new NodeVM({
-    timeout: 5000,
-    wrapper: 'none',
-    console: 'inherit',
-    sandbox: {
-      domain,
-      user,
-      lng,
-      logger,
-      data,
-      variables
-    }
+  const compartment = new Compartment({
+    domain,
+    user,
+    data,
+    variables,
+    logger,
+    lng,
+    console,
+    Math,
+    JSON,
+    Date,
+    setTimeout,
+    setInterval,
+    clearTimeout,
+    clearInterval
   })
 
-  var result = await vm.run(`return (async () => {\n${script}\n})()`)
+  const scriptSource = `
+    (async () => {
+      ${script}
+    })();
+  `
 
-  return {
-    data: result
+  try {
+    return {
+      data: await compartment.evaluate(scriptSource)
+    }
+  } catch (err) {
+    throw new Error(`Script execution failed: ${err.message}`)
   }
 }
 

package/server/index.ts

@@ -15,7 +15,6 @@ process.on('bootstrap-module-start' as any, async ({ app, config, client }: any)
 
     console.log('Scenario Engine has just started.')
   } catch (ex) {
-    ConnectionManager.logger.error(ex)
-    console.log('Just has failed to start Scenario Engine.')
+    ConnectionManager.logger.error('Just has failed to start Scenario Engine.', ex)
   }
 })

package/server/service/payload-log/payload-log-mutation.ts

@@ -146,6 +146,6 @@ export async function createPayloadLog(
       updatedAt: new Date()
     })
   } catch (error) {
-    logger.error(`PayloadLog Error: ${error}`)
+    logger.error(`PayloadLog Error`, error)
   }
 }

package/server/service/scenario/scenario.ts

@@ -98,15 +98,30 @@ export class Scenario {
   @RelationId((scenario: Scenario) => scenario.updater)
   updaterId?: string
 
-  async start(instanceName, variables?: any) {
+  async start(options?: {
+    instanceName?: string;
+    domain?: Domain;
+    user?: User;
+    variables?: any;
+  }) {
     try {
-      await ScenarioEngine.load(instanceName || this.name, this, { domain: this.domain, user: this.updater, variables })
+      await ScenarioEngine.load(options?.instanceName || this.name, 
+        this, 
+        { 
+          domain: options?.domain || this.domain, 
+          user: options?.user || this.updater, 
+          variables: options?.variables 
+        })
     } catch (ex) {}
   }
 
-  async stop(instanceName?) {
+  async stop(options?: {
+    instanceName?: string;
+    domain?: Domain,
+    user?: User
+  }) {
     try {
-      await ScenarioEngine.unload(this.domain, instanceName || this.name)
+      await ScenarioEngine.unload(options?.domain || this.domain, options?.instanceName || this.name)
     } finally {
     }
   }

package/server/service/scenario-instance/scenario-instance-type.ts

@@ -18,10 +18,10 @@ import { Step } from '../step/step-type'
 import { handler as edgeHandler } from '../../engine/edge-client'
 
 const debug = require('debug')('things-factory:integration-base:scenario-instance')
-const { combine, timestamp, splat, printf } = format
+const { combine, errors, splat, printf } = format
 
-const LOGFORMAT = printf(({ level, message, timestamp }) => {
-  return `${timestamp} ${level}: ${message}`
+const LOGFORMAT = printf(({ level, message, timestamp, stack }) => {
+  return `${timestamp} ${level}: ${stack || message}`
 })
 
 const SYSTEM_TZ = Intl.DateTimeFormat().resolvedOptions().timeZone
@@ -228,7 +228,7 @@ export class ScenarioInstance {
       logger:
         context?.logger ||
         createLogger({
-          format: combine(systemTimestamp({ tz: SYSTEM_TZ }), splat(), LOGFORMAT),
+          format: combine(errors({ stack: true }), systemTimestamp({ tz: SYSTEM_TZ }), splat(), LOGFORMAT),
           transports: [
             new (transports as any).DailyRotateFile({
               filename: `logs/${domain.subdomain}/scenario-${scenarioName}-%DATE%.log`,
@@ -320,7 +320,7 @@ export class ScenarioInstance {
       const message = ex.stack ? ex.stack : ex
       const { scenarioName, domain } = this
 
-      this.context.logger.error(ex.message ? ex.message : ex)
+      this.context.logger.error(ex)
 
       debug('failed to run ', `[ Domain: ${domain.name}, Scenario: ${scenarioName} ]\n`, ex)
       this.setState(
@@ -515,7 +515,7 @@ export class ScenarioInstance {
     try {
       step.params = JSON.parse(step.params)
     } catch (ex) {
-      this.context.logger.error(`params(${step.params}) parsing error. params must be a JSON.`)
+      this.context.logger.error(`params(${step.params}) parsing error. params must be a JSON.`, ex)
     }
     step.params = step.params || {}