Add worker.LoadModule for loading ES Modules

Author: phated

binding.cc

@@ -24,10 +24,12 @@ IN THE SOFTWARE.
 #include <stdlib.h>
 #include <string.h>
 #include <string>
+#include <map>
 
 #include "binding.h"
 #include "libplatform/libplatform.h"
 #include "v8.h"
+#include "_cgo_export.h"
 
 using namespace v8;
 
@@ -37,6 +39,7 @@ struct worker_s {
   std::string last_exception;
   Persistent<Function> recv;
   Persistent<Context> context;
+  std::map<std::string, Eternal<Module>> modules;
 };
 
 // Extracts a C string from a V8 Utf8Value.
@@ -90,6 +93,30 @@ void ExitOnPromiseRejectCallback(PromiseRejectMessage promise_reject_message) {
   exit(1);
 }
 
+MaybeLocal<Module> ResolveCallback(Local<Context> context,
+                                   Local<String> specifier,
+                                   Local<Module> referrer) {
+  auto isolate = Isolate::GetCurrent();
+  worker* w = (worker*)isolate->GetData(0);
+
+  HandleScope handle_scope(isolate);
+
+  String::Utf8Value str(specifier);
+  const char* moduleName = *str;
+
+  if (w->modules.count(moduleName) == 0) {
+    std::string out;
+    out.append("Module (");
+    out.append(moduleName);
+    out.append(") has not been loaded");
+    out.append("\n");
+    w->last_exception = out;
+    return MaybeLocal<Module>();
+  }
+
+  return w->modules[moduleName].Get(isolate);
+}
+
 // Exception details will be appended to the first argument.
 std::string ExceptionString(worker* w, TryCatch* try_catch) {
   std::string out;
@@ -151,7 +178,6 @@ std::string ExceptionString(worker* w, TryCatch* try_catch) {
 }
 
 extern "C" {
-#include "_cgo_export.h"
 
 const char* worker_version() { return V8::GetVersion(); }
 
@@ -197,6 +223,90 @@ int worker_load(worker* w, char* name_s, char* source_s) {
   return 0;
 }
 
+int worker_load_module(worker* w, char* name_s, char* source_s, int callback_index) {
+  Locker locker(w->isolate);
+  Isolate::Scope isolate_scope(w->isolate);
+  HandleScope handle_scope(w->isolate);
+
+  Local<Context> context = Local<Context>::New(w->isolate, w->context);
+  Context::Scope context_scope(context);
+
+  TryCatch try_catch(w->isolate);
+
+  Local<String> name = String::NewFromUtf8(w->isolate, name_s);
+  Local<String> source_text = String::NewFromUtf8(w->isolate, source_s);
+
+  Local<Integer> line_offset = Integer::New(w->isolate, 0);
+  Local<Integer> column_offset = Integer::New(w->isolate, 0);
+  Local<Boolean> is_cross_origin = True(w->isolate);
+  Local<Integer> script_id = Local<Integer>();
+  Local<Value> source_map_url = Local<Value>();
+  Local<Boolean> is_opaque = False(w->isolate);
+  Local<Boolean> is_wasm = False(w->isolate);
+  Local<Boolean> is_module = True(w->isolate);
+
+  ScriptOrigin origin(name, line_offset, column_offset, is_cross_origin,
+                      script_id, source_map_url, is_opaque, is_wasm, is_module);
+
+  ScriptCompiler::Source source(source_text, origin);
+  Local<Module> module;
+
+  if (!ScriptCompiler::CompileModule(w->isolate, &source).ToLocal(&module)) {
+    assert(try_catch.HasCaught());
+    w->last_exception = ExceptionString(w, &try_catch);
+    return 1;
+  }
+
+  for (int i = 0; i < module->GetModuleRequestsLength(); i++) {
+    Local<String> dependency = module->GetModuleRequest(i);
+    String::Utf8Value str(dependency);
+    char* dependencySpecifier = *str;
+
+    // If we've already loaded the module, skip resolving it.
+    // TODO: Is there ever a time when the specifier would be the same
+    // but would need to be resolved again?
+    if (w->modules.count(dependencySpecifier) != 0) {
+      continue;
+    }
+
+    int ret = ResolveModule(dependencySpecifier, name_s, callback_index);
+    if (ret != 0) {
+      // TODO: Use module->GetModuleRequestLocation() to get source locations
+      std::string out;
+      out.append("Module (");
+      out.append(dependencySpecifier);
+      out.append(") has not been loaded");
+      out.append("\n");
+      w->last_exception = out;
+      return ret;
+    }
+  }
+
+  Eternal<Module> persModule(w->isolate, module);
+  w->modules[name_s] = persModule;
+
+  Maybe<bool> ok = module->InstantiateModule(context, ResolveCallback);
+
+  if (!ok.FromMaybe(false)) {
+    // TODO: I'm not sure if this is needed
+    if (try_catch.HasCaught()) {
+      assert(try_catch.HasCaught());
+      w->last_exception = ExceptionString(w, &try_catch);
+    }
+    return 2;
+  }
+
+  MaybeLocal<Value> result = module->Evaluate(context);
+
+  if (result.IsEmpty()) {
+    assert(try_catch.HasCaught());
+    w->last_exception = ExceptionString(w, &try_catch);
+    return 2;
+  }
+
+  return 0;
+}
+
 void Print(const FunctionCallbackInfo<Value>& args) {
   bool first = true;
   for (int i = 0; i < args.Length(); i++) {

binding.h

@@ -44,6 +44,7 @@ worker* worker_new(int table_index);
 // returns nonzero on error
 // get error from worker_last_exception
 int worker_load(worker* w, char* name_s, char* source_s);
+int worker_load_module(worker* w, char* name_s, char* source_s, int callback_index);
 
 const char* worker_last_exception(worker* w);
 

worker.go

@@ -38,6 +38,11 @@ type workerTableIndex int
 
 var workerTableLock sync.Mutex
 
+// These are used for handling ModuleResolverCallbacks per LoadModule invocation
+var resolverTableLock sync.Mutex
+var nextResolverToken int
+var resolverFuncs = make(map[int]ModuleResolverCallback)
+
 // This table will store all pointers to all active workers. Because we can't safely
 // pass pointers to Go objects to C, we instead pass a key to this table.
 var workerTable = make(map[workerTableIndex]*worker)
@@ -48,6 +53,9 @@ var workerTableNextAvailable workerTableIndex = 0
 // To receive messages from javascript.
 type ReceiveMessageCallback func(msg []byte) []byte
 
+// To resolve modules from javascript.
+type ModuleResolverCallback func(moduleName, referrerName string) int
+
 // Don't init V8 more than once.
 var initV8Once sync.Once
 
@@ -125,6 +133,23 @@ func recvCb(buf unsafe.Pointer, buflen C.int, index workerTableIndex) C.buf {
 	}
 }
 
+//export ResolveModule
+func ResolveModule(moduleSpecifier *C.char, referrerSpecifier *C.char, resolverToken int) C.int {
+	moduleName := C.GoString(moduleSpecifier)
+	// TODO: Remove this when I'm not dealing with Node resolution anymore
+	referrerName := C.GoString(referrerSpecifier)
+
+	resolverTableLock.Lock()
+	resolve := resolverFuncs[resolverToken]
+	resolverTableLock.Unlock()
+
+	if resolve == nil {
+		return C.int(1)
+	}
+	ret := resolve(moduleName, referrerName)
+	return C.int(ret)
+}
+
 // Creates a new worker, which corresponds to a V8 isolate. A single threaded
 // standalone execution context.
 func New(cb ReceiveMessageCallback) *Worker {
@@ -185,6 +210,37 @@ func (w *Worker) Load(scriptName string, code string) error {
 	return nil
 }
 
+// LoadModule loads and executes a javascript module with filename specified by
+// scriptName and the contents of the module specified by the param code.
+// All `import` dependencies must be loaded before a script otherwise it will error.
+func (w *Worker) LoadModule(scriptName string, code string, resolve ModuleResolverCallback) error {
+	scriptName_s := C.CString(scriptName)
+	code_s := C.CString(code)
+	defer C.free(unsafe.Pointer(scriptName_s))
+	defer C.free(unsafe.Pointer(code_s))
+
+	// Register the callback before we attempt to load a module
+	resolverTableLock.Lock()
+	nextResolverToken++
+	token := nextResolverToken
+	resolverFuncs[token] = resolve
+	resolverTableLock.Unlock()
+	token_i := C.int(token)
+
+	r := C.worker_load_module(w.worker.cWorker, scriptName_s, code_s, token_i)
+
+	// Unregister the callback after the module is loaded
+	resolverTableLock.Lock()
+	delete(resolverFuncs, token)
+	resolverTableLock.Unlock()
+
+	if r != 0 {
+		errStr := C.GoString(C.worker_last_exception(w.worker.cWorker))
+		return errors.New(errStr)
+	}
+	return nil
+}
+
 // Same as Send but for []byte. $recv callback will get an ArrayBuffer.
 func (w *Worker) SendBytes(msg []byte) error {
 	msg_p := C.CBytes(msg)

worker_test.go

@@ -217,6 +217,55 @@ func TestRequestFromJS(t *testing.T) {
 	}
 }
 
+func TestModules(t *testing.T) {
+	var worker *Worker
+	worker = New(func(msg []byte) []byte {
+		t.Fatal("shouldn't recieve Message")
+		return nil
+	})
+	err2 := worker.LoadModule("code.js", `
+		import { test } from "dependency.js";
+		V8Worker2.print(test);
+	`, func(specifier string, referrer string) int {
+		if specifier != "dependency.js" {
+			t.Fatal(`Expected "dependency.js" specifier`)
+		}
+		if referrer != "code.js" {
+			t.Fatal(`Expected "code.js" referrer`)
+		}
+		err1 := worker.LoadModule("dependency.js", `
+			export const test = "ready";
+		`, func(_, _ string) int {
+			t.Fatal(`Expected module resolver callback to not be called`)
+			return 1
+		})
+		if err1 != nil {
+			t.Fatal(err1)
+		}
+		return 0
+	})
+	if err2 != nil {
+		t.Fatal(err2)
+	}
+}
+
+func TestModulesMissingDependency(t *testing.T) {
+	worker := New(func(msg []byte) []byte {
+		t.Fatal("shouldn't recieve Message")
+		return nil
+	})
+	err := worker.LoadModule("code.js", `
+		import { test } from "missing.js";
+		V8Worker2.print(test);
+	`, func(specifier string, referrer string) int {
+		if specifier != "missing.js" {
+			t.Fatal(`Expected "missing.js" specifier`)
+		}
+		return 1
+	})
+	errorContains(t, err, "missing.js")
+}
+
 // Test breaking script execution
 func TestWorkerBreaking(t *testing.T) {
 	worker := New(func(msg []byte) []byte {