quickjs-emscripten-sync 1.0.0 → 1.3.0

package/src/index.test.ts

@@ -1,21 +1,109 @@
 import { getQuickJS } from "quickjs-emscripten";
-import Arena from ".";
+import { describe, expect, test, vi } from "vitest";
+
+import { Arena } from ".";
+
+describe("readme", () => {
+  test("first", async () => {
+    class Cls {
+      field = 0;
+
+      method() {
+        return ++this.field;
+      }
+    }
+
+    const vm = (await getQuickJS()).createVm();
+    const arena = new Arena(vm, { isMarshalable: true });
+
+    // We can pass objects to the VM and run code safely
+    const exposed = {
+      Cls,
+      cls: new Cls(),
+      syncedCls: arena.sync(new Cls()),
+    };
+    arena.expose(exposed);
+
+    expect(arena.evalCode(`cls instanceof Cls`)).toBe(true);
+    expect(arena.evalCode(`cls.field`)).toBe(0);
+    expect(arena.evalCode(`cls.method()`)).toBe(1);
+    expect(arena.evalCode(`cls.field`)).toBe(1);
+
+    expect(arena.evalCode(`syncedCls.field`)).toBe(0);
+    expect(exposed.syncedCls.method()).toBe(1);
+    expect(arena.evalCode(`syncedCls.field`)).toBe(1);
+
+    arena.dispose();
+    vm.dispose();
+  });
+
+  test("usage", async () => {
+    const quickjs = await getQuickJS();
+    const vm = quickjs.createVm();
+
+    // init Arena
+    // ⚠️ Marshaling is opt-in for security reasons.
+    // ⚠️ Be careful when activating marshalling.
+    const arena = new Arena(vm, { isMarshalable: true });
+
+    // expose objects as global objects in QuickJS VM
+    const log = vi.fn();
+    arena.expose({
+      console: { log },
+    });
+    arena.evalCode(`console.log("hello, world");`); // run console.log
+    expect(log).toBeCalledWith("hello, world");
+    arena.evalCode(`1 + 1`); // 2
+
+    // expose objects but also enable sync
+    const data = arena.sync({ hoge: "foo" });
+    arena.expose({ data });
+
+    arena.evalCode(`data.hoge = "bar"`);
+    // eval code and operations to exposed objects are automatically synced
+    expect(data.hoge).toBe("bar");
+    data.hoge = "changed!";
+    expect(arena.evalCode(`data.hoge`)).toBe("changed!");
+
+    // Don't forget calling arena.dispose() before disposing QuickJS VM!
+    arena.dispose();
+    vm.dispose();
+  });
+});
 
 describe("evalCode", () => {
   test("simple object and function", async () => {
     const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm);
+    const arena = new Arena(vm, { isMarshalable: true });
 
     const result = arena.evalCode(
-      `({ a: 1, b: a => Math.floor(a), c: () => { throw new Error("hoge") } })`
+      `({
+        a: 1,
+        b: a => Math.floor(a),
+        c: () => { throw new Error("hoge") },
+        d: (yourFavoriteNumber) => ({
+          myFavoriteNumber: 42,
+          yourFavoriteNumber,
+        }),
+        get e() {
+          return { a: 1 };
+        }
+      })`
     );
     expect(result).toEqual({
       a: 1,
       b: expect.any(Function),
       c: expect.any(Function),
+      d: expect.any(Function),
+      e: { a: 1 },
     });
     expect(result.b(1.1)).toBe(1);
     expect(() => result.c()).toThrow("hoge");
+    expect(result.d(1)).toStrictEqual({
+      myFavoriteNumber: 42,
+      yourFavoriteNumber: 1,
+    });
+    expect(result.e).toStrictEqual({ a: 1 });
 
     arena.dispose();
     vm.dispose();
@@ -23,7 +111,7 @@ describe("evalCode", () => {
 
   test("Math", async () => {
     const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm);
+    const arena = new Arena(vm, { isMarshalable: true });
 
     const VMMath = arena.evalCode(`Math`) as Math;
     expect(VMMath.floor(1.1)).toBe(1);
@@ -34,7 +122,7 @@ describe("evalCode", () => {
 
   test("class", async () => {
     const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm);
+    const arena = new Arena(vm, { isMarshalable: true });
 
     const instance = arena.evalCode(`{
       globalThis.Cls = class D {
@@ -45,7 +133,7 @@ describe("evalCode", () => {
           return ++this.a;
         }
       };
-  
+
       new Cls(100);
     }`);
     const Cls = arena.evalCode(`globalThis.Cls`);
@@ -60,7 +148,7 @@ describe("evalCode", () => {
 
   test("obj", async () => {
     const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm);
+    const arena = new Arena(vm, { isMarshalable: true });
 
     const obj = arena.evalCode(`globalThis.AAA = { a: 1 }`);
 
@@ -78,21 +166,35 @@ describe("evalCode", () => {
 describe("expose without sync", () => {
   test("simple object and function", async () => {
     const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm);
+    const arena = new Arena(vm, { isMarshalable: true });
 
-    arena.expose({
-      obj: {
-        a: 1,
-        b: (a: number) => Math.floor(a),
-        c: () => {
-          throw new Error("hoge");
-        },
+    const obj = {
+      a: 1,
+      b: (a: number) => Math.floor(a),
+      c: () => {
+        throw new Error("hoge");
+      },
+      d: (yourFavoriteNumber: number) => ({
+        myFavoriteNumber: 42,
+        yourFavoriteNumber,
+      }),
+      get e() {
+        return { a: 1 };
       },
+    };
+    arena.expose({
+      obj,
     });
 
+    expect(arena.evalCode(`obj`)).toBe(obj);
     expect(arena.evalCode(`obj.a`)).toBe(1);
     expect(arena.evalCode(`obj.b(1.1)`)).toBe(1);
     expect(() => arena.evalCode(`obj.c()`)).toThrow("hoge");
+    expect(arena.evalCode(`obj.d(1)`)).toStrictEqual({
+      myFavoriteNumber: 42,
+      yourFavoriteNumber: 1,
+    });
+    expect(arena.evalCode(`obj.e`)).toStrictEqual({ a: 1 });
 
     arena.dispose();
     vm.dispose();
@@ -100,10 +202,12 @@ describe("expose without sync", () => {
 
   test("Math", async () => {
     const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm);
+    const arena = new Arena(vm, { isMarshalable: true });
 
-    arena.expose({ Math });
-    expect(arena.evalCode(`Math.floor(1.1)`)).toBe(1);
+    arena.expose({ Math2: Math });
+    expect(arena.evalCode(`Math`)).not.toBe(Math);
+    expect(arena.evalCode(`Math2`)).toBe(Math);
+    expect(arena.evalCode(`Math2.floor(1.1)`)).toBe(1);
 
     arena.dispose();
     vm.dispose();
@@ -111,7 +215,7 @@ describe("expose without sync", () => {
 
   test("class", async () => {
     const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm);
+    const arena = new Arena(vm, { isMarshalable: true });
 
     class D {
       a: number;
@@ -125,7 +229,10 @@ describe("expose without sync", () => {
       }
     }
 
-    arena.expose({ D, d: new D(100) });
+    const d = new D(100);
+    arena.expose({ D, d });
+    expect(arena.evalCode(`D`)).toBe(D);
+    expect(arena.evalCode(`d`)).toBe(d);
     expect(arena.evalCode(`d instanceof D`)).toBe(true);
     expect(arena.evalCode(`d.a`)).toBe(101);
     expect(arena.evalCode(`d.foo()`)).toBe(102);
@@ -137,7 +244,7 @@ describe("expose without sync", () => {
 
   test("object and function", async () => {
     const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm);
+    const arena = new Arena(vm, { isMarshalable: true });
 
     const obj = {
       a: 1,
@@ -146,9 +253,13 @@ describe("expose without sync", () => {
         return this.a++;
       },
     };
-    const obj2 = arena.expose({ obj });
+    arena.expose({ obj });
 
+    expect(arena.evalCode(`obj`)).toBe(obj);
+    expect(arena.evalCode(`obj.a`)).toBe(1);
+    expect(arena.evalCode(`obj.b`)).toBe(obj.b);
     expect(arena.evalCode(`obj.b(1.1)`)).toBe(1);
+    expect(arena.evalCode(`obj.c`)).toBe(obj.c);
     expect(arena.evalCode(`obj.c()`)).toBe(1);
     expect(arena.evalCode(`obj.a`)).toBe(2);
     expect(obj.a).toBe(2);
@@ -156,8 +267,7 @@ describe("expose without sync", () => {
     expect(arena.evalCode(`obj.a`)).toBe(3);
     expect(obj.a).toBe(3);
 
-    expect(obj).toBe(obj2.obj);
-    obj2.obj.a = 10;
+    obj.a = 10;
     expect(obj.a).toBe(10);
     expect(arena.evalCode(`obj.a`)).toBe(3); // not affected
 
@@ -171,9 +281,9 @@ describe("expose without sync", () => {
 });
 
 describe("expose with sync", () => {
-  test("object and function", async () => {
+  test("sync before expose", async () => {
     const vm = (await getQuickJS()).createVm();
-    const arena = new Arena(vm);
+    const arena = new Arena(vm, { isMarshalable: true });
 
     const obj = {
       a: 1,
@@ -182,9 +292,64 @@ describe("expose with sync", () => {
         return this.a++;
       },
     };
-    const obj2 = arena.expose({ obj }, true);
+    const obj2 = arena.sync(obj);
+    arena.expose({ obj: obj2 });
+
+    const obj3 = arena.evalCode(`obj`);
+    expect(obj3).toBe(obj2);
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj.c); // wrapped object
+    expect(arena.evalCode(`obj.b`)).not.toBe(obj2.b); // wrapped object
+    expect(arena.evalCode(`obj.b`)).not.toBe(obj3.b); // wrapped object
+    expect(arena.evalCode(`obj.b(1.1)`)).toBe(1);
+    expect(arena.evalCode(`obj.a`)).toBe(1);
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj.c); // wrapped object
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj2.c); // wrapped object
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj3.c); // wrapped object
+    expect(arena.evalCode(`obj.c()`)).toBe(1);
+    expect(arena.evalCode(`obj.a`)).toBe(2);
+    expect(obj.a).toBe(2);
+    expect(arena.evalCode(`obj.c()`)).toBe(2);
+    expect(arena.evalCode(`obj.a`)).toBe(3);
+    expect(obj.a).toBe(3);
+
+    expect(obj).not.toBe(obj2);
+    obj2.a = 10;
+    expect(obj.a).toBe(10);
+    expect(arena.evalCode(`obj.a`)).toBe(10); // affected
 
+    arena.evalCode(`obj.a = 100`);
+    expect(obj.a).toBe(100); // affected
+    expect(arena.evalCode(`obj.a`)).toBe(100);
+
+    arena.dispose();
+    vm.dispose();
+  });
+
+  test("sync after expose", async () => {
+    const vm = (await getQuickJS()).createVm();
+    const arena = new Arena(vm, { isMarshalable: true });
+
+    const obj = {
+      a: 1,
+      b: (a: number) => Math.floor(a),
+      c() {
+        return this.a++;
+      },
+    };
+    arena.expose({ obj });
+    const obj2 = arena.sync(obj);
+
+    const obj3 = arena.evalCode(`obj`);
+    expect(obj3).not.toBe(obj); // wrapped object
+    expect(obj3).not.toBe(obj2); // wrapped object
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj.c); // wrapped object
+    expect(arena.evalCode(`obj.b`)).not.toBe(obj2.b); // wrapped object
+    expect(arena.evalCode(`obj.b`)).not.toBe(obj3.b); // wrapped object
     expect(arena.evalCode(`obj.b(1.1)`)).toBe(1);
+    expect(arena.evalCode(`obj.a`)).toBe(1);
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj.c); // wrapped object
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj2.c); // wrapped object
+    expect(arena.evalCode(`obj.c`)).not.toBe(obj3.c); // wrapped object
     expect(arena.evalCode(`obj.c()`)).toBe(1);
     expect(arena.evalCode(`obj.a`)).toBe(2);
     expect(obj.a).toBe(2);
@@ -192,8 +357,8 @@ describe("expose with sync", () => {
     expect(arena.evalCode(`obj.a`)).toBe(3);
     expect(obj.a).toBe(3);
 
-    expect(obj).not.toBe(obj2.obj);
-    obj2.obj.a = 10;
+    expect(obj).not.toBe(obj2);
+    obj2.a = 10;
     expect(obj.a).toBe(10);
     expect(arena.evalCode(`obj.a`)).toBe(10); // affected
 
@@ -208,13 +373,12 @@ describe("expose with sync", () => {
 
 test("evalCode -> expose", async () => {
   const vm = (await getQuickJS()).createVm();
-  const arena = new Arena(vm);
+  const arena = new Arena(vm, { isMarshalable: true });
 
-  const { obj } = arena.expose(
-    { obj: arena.evalCode(`({ a: 1, b: 1 })`) },
-    true
-  );
+  const obj = arena.evalCode(`({ a: 1, b: 1 })`);
+  arena.expose({ obj });
 
+  expect(obj).toBe(obj);
   expect(obj.a).toBe(1);
   expect(arena.evalCode(`obj.a`)).toBe(1);
   expect(obj.b).toBe(1);
@@ -240,21 +404,34 @@ test("evalCode -> expose", async () => {
 
 test("expose -> evalCode", async () => {
   const vm = (await getQuickJS()).createVm();
-  const arena = new Arena(vm);
+  const arena = new Arena(vm, { isMarshalable: true });
 
   const obj = { a: 1 };
-  const { obj: obj2 } = arena.expose({ obj }, true);
-  const obj3 = arena.evalCode(`obj`);
+  arena.expose({ obj });
+  const obj2 = arena.evalCode(`obj`);
 
-  expect(obj3).toBe(obj2);
+  expect(obj2).toBe(obj);
 
-  obj3.a = 2;
+  obj2.a = 2;
   expect(obj.a).toBe(2);
-  expect(arena.evalCode(`obj.a`)).toBe(2);
+  expect(arena.evalCode(`obj.a`)).toBe(1);
+
+  arena.evalCode("obj.a = 3");
+  expect(obj.a).toBe(2);
+  expect(arena.evalCode(`obj.a`)).toBe(3);
+
+  arena.dispose();
+  vm.dispose();
+});
+
+test("evalCode -> expose -> evalCode", async () => {
+  const vm = (await getQuickJS()).createVm();
+  const arena = new Arena(vm, { isMarshalable: true });
 
-  arena.evalCode("obj.a = 4");
-  expect(obj.a).toBe(4);
-  expect(arena.evalCode(`obj.a`)).toBe(4);
+  const obj = [1];
+  expect(arena.evalCode("a => a[0] + 10")(obj)).toBe(11);
+  arena.expose({ obj });
+  expect(arena.evalCode("obj")).toBe(obj);
 
   arena.dispose();
   vm.dispose();
@@ -262,7 +439,7 @@ test("expose -> evalCode", async () => {
 
 test("register and unregister", async () => {
   const vm = (await getQuickJS()).createVm();
-  const arena = new Arena(vm, { registeredObjects: [] });
+  const arena = new Arena(vm, { isMarshalable: true, registeredObjects: [] });
 
   arena.register(Math, `Math`);
   expect(arena.evalCode(`Math`)).toBe(Math);
@@ -283,6 +460,7 @@ test("register and unregister", async () => {
 test("registeredObjects option", async () => {
   const vm = (await getQuickJS()).createVm();
   const arena = new Arena(vm, {
+    isMarshalable: true,
     registeredObjects: [[Symbol.iterator, "Symbol.iterator"]],
   });
 
@@ -295,14 +473,51 @@ test("registeredObjects option", async () => {
   vm.dispose();
 });
 
-test("isMarshalable option", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const arena = new Arena(vm, {
-    isMarshalable: o => o !== globalThis,
+describe("isMarshalable option", () => {
+  test("false", async () => {
+    const vm = (await getQuickJS()).createVm();
+    const arena = new Arena(vm, { isMarshalable: false });
+
+    expect(arena.evalCode(`s => s === undefined`)(globalThis)).toBe(true);
+    expect(arena.evalCode(`s => s === undefined`)({})).toBe(true);
+    arena.expose({ aaa: globalThis });
+    expect(arena.evalCode(`aaa`)).toBeUndefined();
+
+    arena.dispose();
+    vm.dispose();
   });
 
-  expect(arena.evalCode(`s => s === undefined`)(globalThis)).toBe(true);
+  test("json", async () => {
+    const vm = (await getQuickJS()).createVm();
+    const arena = new Arena(vm, { isMarshalable: "json" });
 
-  arena.dispose();
-  vm.dispose();
+    const obj = { a: () => {}, b: new Date(), c: [() => {}, 1] };
+    const objJSON = { b: obj.b.toISOString(), c: [null, 1] };
+    const objJSON2 = arena.evalCode(`a => a`)(obj);
+    expect(objJSON2).toStrictEqual(objJSON);
+    arena.expose({ obj });
+    const exposedObj = arena.evalCode(`obj`);
+    expect(exposedObj).toStrictEqual(objJSON);
+    expect(exposedObj).not.toBe(objJSON2);
+
+    arena.dispose();
+    vm.dispose();
+  });
+
+  test("conditional", async () => {
+    const vm = (await getQuickJS()).createVm();
+    const arena = new Arena(vm, {
+      isMarshalable: (o) => o !== globalThis,
+    });
+
+    const obj = { a: 1 };
+    expect(arena.evalCode(`s => s === undefined`)(globalThis)).toBe(true);
+    expect(arena.evalCode(`s => s === undefined`)(obj)).toBe(false);
+    arena.expose({ aaa: globalThis, bbb: obj });
+    expect(arena.evalCode(`aaa`)).toBeUndefined();
+    expect(arena.evalCode(`bbb`)).toBe(obj);
+
+    arena.dispose();
+    vm.dispose();
+  });
 });