Merge pull request #71 from yeuai/dev-context

Wrap code for browser

Author: vunb

src/engine/context.ts

@@ -4,7 +4,7 @@ import { Struct } from './struct';
 import { IActivator } from '../interfaces/activator';
 import { Logger } from '../lib/logger';
 import { Trigger } from './trigger';
-import { wrapCode } from '../plugins/built-in';
+import { wrapCode, wrapCodeBrowser } from '../plugins/built-in';
 import * as utils from '../lib/utils';
 
 /**
@@ -161,6 +161,7 @@ export class Context {
       } else if (/^plugin/.test(item)) {
         const vPlugin = this.directives.get(item) as Struct;
         const vCode = wrapCode(vPlugin.value);
+        const vCodeBrowser = wrapCodeBrowser(vPlugin.value);
         const vName = vPlugin.name.replace(/^plugin:/, '');
         // this.this.logger.debug(`javascript code: /plugin: ${vName} => ${vCode}`);
         this.logger.debug(`add custom plugin & save handler in it own directive: /${vPlugin.name}`);
@@ -177,7 +178,7 @@ export class Context {
           } else {
             this.logger.debug(`Execute /plugin: ${vName} in browser!`);
             const { VmRunner } = await import('../lib/vm');
-            const vPreProcess = await VmRunner.run(vCode, { req, ctx, utils, logger });
+            const vPreProcess = await VmRunner.run(vCodeBrowser, { req, ctx, utils, logger });
             const vPostProcessingCallback = await vPreProcess();
             // support post-processing
             this.logger.debug(`Plugin [${vName}] has pre-processed!`);

src/interfaces/types.ts

@@ -2,6 +2,7 @@ import { Request, Context } from '../engine';
 
 export type TestConditionalCallback = (data: string, ...args: any[]) => boolean | void;
 export type PluginCallback = (req: Request, ctx: Context) => void | Promise<any> | PluginCallback;
+export type PluginWrapperCallback = () => PluginCallback;
 
 /**
  * Dialogue struct types

src/lib/vm.ts

@@ -1,4 +1,5 @@
 import { Script } from 'vm';
+import { PluginWrapperCallback } from '../interfaces/types';
 
 export class VmRunner {
   runInVm(code: string, sandbox: any, path?: string) {
@@ -26,7 +27,7 @@ export class VmRunner {
    * @param sandbox
    * @returns
    */
-  static run(code: string, sandbox: any): () => void {
+  static run(code: string, sandbox: any): PluginWrapperCallback {
     const script = new Script(code, { timeout: 5000 });
     const retValue = script.runInNewContext(sandbox);
     return retValue;

src/lib/vm2.ts

@@ -1,4 +1,5 @@
 import { NodeVM, VMScript } from 'vm2';
+import { PluginWrapperCallback } from '../interfaces/types';
 
 export class VmRunner {
   /**
@@ -23,7 +24,7 @@ export class VmRunner {
    * @param sandbox
    * @returns
    */
-  static run(code: string, sandbox: any): () => void {
+  static run(code: string, sandbox: any): PluginWrapperCallback {
     const vm = new NodeVM({
       wrapper: 'none',
       sandbox,

src/plugins/built-in.ts

@@ -65,3 +65,23 @@ export function wrapCode(plugin: string): string {
     }
   })({req, ctx, utils, logger})`;
 }
+
+/**
+ * Extract plugin code & wrap it for Browser!
+ * @param plugin
+ * @returns
+ */
+export function wrapCodeBrowser(plugin: string): string {
+  const vCode = plugin
+    .replace(/```js([^`]*)```/, (m: string, code: string) => code)
+    .replace(/~~~js([^~]*)~~~/, (m: string, code: string) => code);
+
+  return `
+  () => (async ({req, ctx, utils, logger}) => {
+    try {
+      ${vCode}
+    } catch (error) {
+      logger.error('Execute error!', error);
+    }
+  })({req, ctx, utils, logger})`;
+}

test/lib/vm.spec.ts

@@ -0,0 +1,44 @@
+import { expect } from 'chai';
+import { Context, Request } from '../../src/common';
+import { VmRunner as VmRunnerBrowser } from '../../src/lib/vm';
+import { VmRunner as VmRunnerNode } from '../../src/lib/vm2';
+import { wrapCode as wrapCodeNode, wrapCodeBrowser } from '../../src/plugins/built-in';
+import * as utils from '../../src/lib/utils';
+import { Logger } from '../../src/lib/logger';
+
+describe('VmRunner', () => {
+
+  describe('VM for Browser', () => {
+    it('should run the code', async () => {
+      const vCode = wrapCodeBrowser(`logger.info('Ok'); return () => {req.message = 123}`);
+
+      const req = new Request();
+      const ctx = new Context();
+      const logger = new Logger('TESTER');
+      const vPreProcess = await VmRunnerBrowser.run(vCode, { req, ctx, utils, logger });
+      const vPostProcessingCallback = await vPreProcess();
+      expect(vPreProcess).not.eq(undefined);
+      expect(req.message).not.eq(123);
+
+      vPostProcessingCallback(req, ctx);
+      expect(req.message).eq(123);
+    });
+  });
+
+  describe('VM for Node', () => {
+    it('should run the code', async () => {
+      const vCode = wrapCodeNode(`logger.info('Ok'); return () => {req.message = 123}`);
+
+      const req = new Request();
+      const ctx = new Context();
+      const logger = new Logger('TESTER');
+      const vPreProcess = await VmRunnerNode.run(vCode, { req, ctx, utils, logger });
+      const vPostProcessingCallback = await vPreProcess();
+      expect(vPreProcess).not.eq(undefined);
+      expect(req.message).not.eq(123);
+
+      vPostProcessingCallback(req, ctx);
+      expect(req.message).eq(123);
+    });
+  });
+});