feat(core): add default evaluation service

Author: zzhenryquezz

packages/core/entities/evaluation-output.ts

@@ -0,0 +1,27 @@
+export default class EvaluationOutput {
+    public error: any | null
+    public result: any | null
+    public logs: string[]
+
+    constructor(props: EvaluationOutput) {
+        this.error = props.error
+        this.result = props.result
+        this.logs = props.logs
+    }
+
+    public static error(error: any, logs: EvaluationOutput['logs'] = []) {
+        return new EvaluationOutput({
+            error,
+            logs,
+            result: null,
+        })
+    }
+
+    public static formatLog(arg: any) {
+        if (typeof arg === 'string') {
+            return arg
+        }
+
+        return JSON.stringify(arg)
+    }
+}

packages/core/gateways/evaluation/implementations.spec.ts

@@ -0,0 +1,90 @@
+import { test } from '@japa/runner'
+import IEvaluationService from './evaluation'
+import DefaultEvaluation from './implementations/default-evaluation'
+import NodeVMEvaluation from './implementations/node-vm-evaluation'
+
+interface Services {
+    name: string
+    service: IEvaluationService
+}
+
+test.group('evaluation (unit)', () => {
+    const services: Services[] = [
+        { name: 'default', service: new DefaultEvaluation() },
+        { name: 'node-vm', service: new NodeVMEvaluation() },
+    ]
+
+    test('should "{name}" execute script and return result ')
+        .with(services)
+        .run(async ({ expect }, { service }) => {
+            const result = await service.evaluate('setResult(4)')
+
+            expect(result.result).toBe(4)
+        })
+
+    test('should "{name}" execute Promise script and set result')
+        .with(services)
+        .run(async ({ expect }, { service }) => {
+            const result = await service.evaluate(`
+            const main = () => Promise.resolve(4)
+
+            setResult(await main())
+        `)
+
+            expect(result.result).toBe(4)
+        })
+
+    test('should "{name}" execute script with scope')
+        .with(services)
+        .run(async ({ expect }, { service }) => {
+            let data = {}
+
+            const scope = {
+                setData: (arg: any) => (data = arg),
+            }
+
+            await service.evaluate('setData([1,2,3])', scope)
+
+            expect(data).toEqual([1, 2, 3])
+        })
+
+    test('should "{name}" return error if have one')
+        .with(services)
+        .run(async ({ expect }, { service }) => {
+            const result = await service.evaluate(`
+            const main = () => Promise.reject('Error in script')
+
+            setResult(await main())
+        `)
+
+            expect(result.error).toEqual('Error in script')
+        })
+
+    test('should "{name}" execute script and return logs')
+        .with(services)
+        .run(async ({ expect }, { service }) => {
+            const result = await service.evaluate(`
+            console.log('Hello')
+            console.log({ key: 123 })
+            console.log([ { key: 'abc' } ])            
+        `)
+
+            expect(result.logs).toEqual(['Hello', '{"key":123}', '[{"key":"abc"}]'])
+        })
+
+    test('should "{name}" not be able to use import')
+        .with(services)
+        .run(async ({ expect }, { service }) => {
+            const result = await service.evaluate(`import fs from 'fs'`)
+
+            expect(result.error.message).toBe('Cannot use import statement outside a module')
+        })
+
+    test('should "{name}" not be able to use require')
+        .with(services)
+        .run(async ({ expect }, { service }) => {
+            const result = await service.evaluate(`const fs = require('fs')`)
+
+            expect(result.error.message).toBe('require is not defined')
+        })
+})

packages/core/gateways/evaluation/implementations/default-evaluation.ts

@@ -0,0 +1,53 @@
+import EvaluationOutput from '../../../entities/evaluation-output'
+import IEvaluationService from '../evaluation'
+import escapeRegExp from 'lodash/escapeRegExp'
+
+export default class DefaultEvaluation implements IEvaluationService {
+    protected async _evaluate(code: string, scope?: Record<string, any>) {
+        const logs: string[] = []
+        let result = null
+        const error = null
+
+        const sandbox = {
+            ...scope,
+            setResult: (data: any) => (result = data),
+            console: {
+                log: (...args: any) => logs.push(args.map(EvaluationOutput.formatLog).join(' ')),
+            },
+        }
+
+        let fixCode = code
+
+        for (const key in sandbox) {
+            fixCode = fixCode
+                .replace(new RegExp(escapeRegExp(`${key}.`), 'g'), `context.${key}.`)
+                .replace(new RegExp(escapeRegExp(`${key}(`), 'g'), `context.${key}(`)
+        }
+
+        const fn = new Function(`
+            const context = this
+
+            async function run(){
+                ${fixCode}
+            }
+
+            return run()
+        `)
+
+        await fn.bind(sandbox)()
+
+        return {
+            result,
+            error,
+            logs,
+        }
+    }
+
+    public async evaluate(code: string, scope?: Record<string, any>) {
+        try {
+            return await this._evaluate(code, scope)
+        } catch (error: any) {
+            return EvaluationOutput.error(error)
+        }
+    }
+}

packages/core/gateways/evaluation/implementations/node-vm-evaluation.spec.ts

@@ -1,23 +1,6 @@
 import vm from 'vm'
-import util from 'util'
 
-import * as ts from 'typescript'
-
-function tsCompile(source: string, options: ts.TranspileOptions = {}): string {
-    // Default options -- you could also perform a merge, or use the project tsconfig.json
-    if (null === options) {
-        options = { compilerOptions: { module: ts.ModuleKind.CommonJS } }
-    }
-    return ts.transpileModule(source, options).outputText
-}
-
-const format = (args: any) => {
-    if (typeof args === 'string') {
-        return args
-    }
-
-    return util.inspect(args)
-}
+import EvaluationOutput from '../../../entities/evaluation-output'
 
 export default class ScriptService {
     protected async _evaluate(code: string, scope?: Record<string, any>) {
@@ -28,13 +11,13 @@ export default class ScriptService {
         const sandbox = {
             setResult: (data: any) => (result = data),
             console: {
-                log: (...args: any) => logs.push(args.map(format).join(' ')),
+                log: (...args: any) => logs.push(args.map(EvaluationOutput.formatLog).join(' ')),
             },
             ...scope,
             main: (): Promise<any> => Promise.resolve('Error executing script'),
         }
 
-        const executable = new vm.Script(`async function main(){ ${tsCompile(code)} }`)
+        const executable = new vm.Script(`async function main(){ ${code} }`)
         const context = vm.createContext(sandbox)
 
         executable.runInContext(context, {})
@@ -52,14 +35,7 @@ export default class ScriptService {
         try {
             return await this._evaluate(code, scope)
         } catch (error: any) {
-            return {
-                result: null,
-                error: {
-                    message: error.message,
-                    stack: error.stack,
-                },
-                logs: [],
-            }
+            return EvaluationOutput.error(error)
         }
     }
 }

packages/core/gateways/evaluation/implementations/node-vm-evaluation.ts

@@ -2,7 +2,6 @@ import { test } from '@japa/runner'
 import DirectoryEntry from '../../entities/directory-entry'
 import Workspace from '../../entities/workspace'
 
-import InMemoryApp from '../../__tests__/app'
 import InMemoryAppConfig from '../../__tests__/in-memory-config'
 import ExecuteScript from './execute-script'
 
@@ -27,24 +26,6 @@ test.group('execute-script (use-case)', (group) => {
         expect(result).toBe('Hello word')
     })
 
-    test('should throw an error when trying to use require("fs")', async ({ expect }) => {
-        const result = await useCase.execute({
-            workspaceId: workspace.id,
-            content: 'const fs = require("fs")',
-        })
-
-        expect(result.error.message).toBe('require is not defined')
-    })
-
-    test('should throw an error when trying to use import fs from "fs"', async ({ expect }) => {
-        const result = await useCase.execute({
-            workspaceId: workspace.id,
-            content: `import fs from "fs"`,
-        })
-
-        expect(result.error.message).toBe('exports is not defined')
-    })
-
     test('should create a file in workspace', async ({ expect }) => {
         await useCase.execute({
             workspaceId: workspace.id,