vm: add import assertion support

PR-URL: #37176 Reviewed-By: Anna Henningsen <anna@addaleax.net> Reviewed-By: Michaël Zasso <targos@protonmail.com>
nodejs · Mar 24, 2021 · 4f354b0 · 4f354b0
1 parent 86bf341
commit 4f354b0
Show file tree

Hide file tree

Showing 4 changed files with 40 additions and 4 deletions.
diff --git a/doc/api/vm.md b/doc/api/vm.md
@@ -617,6 +617,16 @@ The identifier of the current module, as set in the constructor.
     import foo from 'foo';
     //              ^^^^^ the module specifier
     ```
+  * `extra` {Object}
+    * `assert` {Object} The data from the assertion:
+      <!-- eslint-skip -->
+      ```js
+      import foo from 'foo' assert { name: 'value' };
+      //                           ^^^^^^^^^^^^^^^^^ the assertion
+      ```
+      Per ECMA-262, hosts are expected to ignore assertions that they do not
+      support, as opposed to, for example, triggering an error if an
+      unsupported assertion is present.
 
   * `referencingModule` {vm.Module} The `Module` object `link()` is called on.
   * Returns: {vm.Module|Promise}

diff --git a/lib/internal/vm/module.js b/lib/internal/vm/module.js
@@ -308,8 +308,8 @@ class SourceTextModule extends Module {
     this[kLink] = async (linker) => {
       this.#statusOverride = 'linking';
 
-      const promises = this[kWrap].link(async (identifier) => {
-        const module = await linker(identifier, this);
+      const promises = this[kWrap].link(async (identifier, assert) => {
+        const module = await linker(identifier, this, { assert });
         if (module[kWrap] === undefined) {
           throw new ERR_VM_MODULE_NOT_MODULE();
         }

diff --git a/src/module_wrap.cc b/src/module_wrap.cc
@@ -279,8 +279,20 @@ void ModuleWrap::Link(const FunctionCallbackInfo<Value>& args) {
     Utf8Value specifier_utf8(env->isolate(), specifier);
     std::string specifier_std(*specifier_utf8, specifier_utf8.length());
 
+    Local<FixedArray> raw_assertions = module_request->GetImportAssertions();
+    Local<Object> assertions =
+        Object::New(isolate, v8::Null(env->isolate()), nullptr, nullptr, 0);
+    for (int i = 0; i < raw_assertions->Length(); i += 3) {
+      assertions
+          ->Set(env->context(),
+                Local<String>::Cast(raw_assertions->Get(env->context(), i)),
+                Local<Value>::Cast(raw_assertions->Get(env->context(), i + 1)))
+          .ToChecked();
+    }
+
     Local<Value> argv[] = {
-      specifier
+        specifier,
+        assertions,
     };
 
     MaybeLocal<Value> maybe_resolve_return_value =

diff --git a/test/parallel/test-vm-module-link.js b/test/parallel/test-vm-module-link.js
@@ -1,6 +1,6 @@
 'use strict';
 
-// Flags: --experimental-vm-modules
+// Flags: --experimental-vm-modules --harmony-import-assertions
 
 const common = require('../common');
 
@@ -124,12 +124,26 @@ async function circular2() {
   await rootModule.evaluate();
 }
 
+async function asserts() {
+  const m = new SourceTextModule(`
+  import "foo" assert { n1: 'v1', n2: 'v2' };
+  `, { identifier: 'm' });
+  await m.link((s, r, p) => {
+    assert.strictEqual(s, 'foo');
+    assert.strictEqual(r.identifier, 'm');
+    assert.strictEqual(p.assert.n1, 'v1');
+    assert.strictEqual(p.assert.n2, 'v2');
+    return new SourceTextModule('');
+  });
+}
+
 const finished = common.mustCall();
 
 (async function main() {
   await simple();
   await depth();
   await circular();
   await circular2();
+  await asserts();
   finished();
 })().then(common.mustCall());