More incremental impl of new module registry

Starts adding api tests, fixing up some behaviors.

src/workerd/api/BUILD.bazel

@@ -534,3 +534,9 @@ wd_test(
  "//conditions:default": ["@platforms//:incompatible"],
  }),
 )
+
+wd_test(
+ src = "tests/new-module-registry-test.wd-test",
+ args = ["--experimental"],
+ data = ["tests/new-module-registry-test.js"],
+)

src/workerd/api/tests/new-module-registry-test.js

@@ -0,0 +1,176 @@
+import {
+ notStrictEqual,
+ ok,
+ rejects,
+ strictEqual,
+ deepStrictEqual,
+} from 'assert';
+import { foo, default as def } from 'foo';
+import { default as fs } from 'node:fs';
+import { Buffer } from 'buffer';
+const { foo: foo2, default: def2 } = await import('bar');
+
+// Verify that import.meta.url is correct here.
+strictEqual(import.meta.url, 'file:///worker');
+
+// Verify that import.meta.main is true here.
+ok(import.meta.main);
+
+// Verify that import.meta.resolve provides correct results here.
+// The input should be interpreted as a URL and normalized according
+// to the rules in the WHATWG URL specification.
+strictEqual(import.meta.resolve('./.././test/.././../foo'), 'file:///foo');
+
+// There are four tests at this top level... one for the import of the node:assert
+// module without the node: prefix specifier, two for the imports of the foo and
+// bar modules from the worker, and one for the aliases node:fs module from the
+// module worker.
+
+strictEqual(foo, 1);
+strictEqual(def, 2);
+strictEqual(foo2, 1);
+strictEqual(def2, 2);
+strictEqual(fs, 'abc');
+
+// Equivalent to the above, but using the file: URL scheme.
+import { foo as foo3, default as def3 } from 'file:///foo';
+strictEqual(foo, foo3);
+strictEqual(def, def3);
+
+import * as text from 'text';
+strictEqual(text.default, 'abc');
+
+import * as data from 'data';
+strictEqual(Buffer.from(data.default).toString(), 'abcdef');
+
+import * as json from 'json';
+deepStrictEqual(json.default, { foo: 1 });
+
+await rejects(import('invalid-json'), {
+ message: /Unexpected non-whitespace character after JSON/,
+});
+
+await rejects(import('module-not-found'), {
+ message: /Module not found: file:\/\/\/module-not-found/,
+});
+
+// Verify that a module is unable to perform IO operations at the top level, even if
+// the dynamic import is initiated within the scope of an active IoContext.
+export const noTopLevelIo = {
+ async test() {
+ await rejects(import('bad'), {
+ message: /^Disallowed operation called within global scope/,
+ });
+ },
+};
+
+// Verify that async local storage is propagated into dynamic imports.
+export const alsPropagationDynamicImport = {
+ async test() {
+ const { AsyncLocalStorage } = await import('async_hooks');
+ globalThis.als = new AsyncLocalStorage();
+ const res = await globalThis.als.run(123, () => import('als'));
+ strictEqual(res.default, 123);
+ },
+};
+
+// Query strings and fragments create new instances of known modules.
+export const queryAndFragment = {
+ async test() {
+ // Each resolves the same underlying module but creates a new instance.
+ // The exports should be the same but the module namespaces should be different.
+
+ const a = await import('foo?query');
+ const b = await import('foo#fragment');
+ const c = await import('foo?query#fragment');
+ const d = await import('foo');
+
+ strictEqual(a.default, 2);
+ strictEqual(a.foo, 1);
+ strictEqual(a.default, b.default);
+ strictEqual(a.default, c.default);
+ strictEqual(a.default, d.default);
+ strictEqual(a.foo, b.foo);
+ strictEqual(a.foo, c.foo);
+ strictEqual(a.foo, d.foo);
+
+ notStrictEqual(a, b);
+ notStrictEqual(a, c);
+ notStrictEqual(a, d);
+ notStrictEqual(b, c);
+ notStrictEqual(b, d);
+ notStrictEqual(c, d);
+
+ // The import.meta.url for each should match the specifier used to import the instance.
+ strictEqual(a.bar, 'file:///foo?query');
+ strictEqual(b.bar, 'file:///foo#fragment');
+ strictEqual(c.bar, 'file:///foo?query#fragment');
+ strictEqual(d.bar, 'file:///foo');
+ },
+};
+
+// We do not currently support import assertions/attributes. Per the recommendation
+// in the spec, we throw an error when they are encountered.
+export const importAssertionsFail = {
+ async test() {
+ await rejects(import('ia'), {
+ message: /^Import attributes are not supported/,
+ });
+ await rejects(import('foo', { with: { a: 'abc' } }), {
+ message: /^Import attributes are not supported/,
+ });
+ },
+};
+
+export const invalidUrlAsSpecifier = {
+ async test() {
+ await rejects(import('zebra: not a \x00 valid URL'), {
+ message: /Module not found/,
+ });
+ },
+};
+
+export const evalErrorsInEsmTopLevel = {
+ async test() {
+ await rejects(import('esm-error'), {
+ message: /boom/,
+ });
+ await rejects(import('esm-error-dynamic'), {
+ message: /boom/,
+ });
+ },
+};
+
+// TODO(now): Tests
+// * [ ] Include tests for all known module types
+// * [x] ESM
+// * [ ] CommonJS
+// * [x] Text
+// * [x] Data
+// * [x] JSON
+// * [ ] WASM
+// * [ ] Python
+// * [x] IO is forbidden in top-level module scope
+// * [x] Async local storage context is propagated into dynamic imports
+// * [x] Static import correctly handles node: modules with/without the node: prefix
+// * [x] Dynamic import correctly handles node: modules with/without the node: prefix
+// * [x] Worker bundle can alias node: modules
+// * [x] modules not found are correctly reported as errors
+// * [x] Errors during ESM evaluation are correctly reported
+// * [x] Errors during dynamic import are correctly reported
+// * [x] Errors in JSON module parsing are correctly reported
+// * [x] Module specifiers are correctly handled as URLs
+// * [x] Querys and fragments resolve new instances of known modules
+// * [x] URL resolution works correctly
+// * [x] Invalid URLs are correctly reported as errors
+// * [x] Import assertions should be rejected
+// * [ ] require(...) Works in CommonJs Modules
+// * [ ] require(...) correctly handles node: modules with/without the node: prefix
+// * [ ] Circular dependencies are correctly handled
+// * [ ] Errors during CommonJs evaluation are correctly reported
+// * [ ] Entry point ESM with no default export is correctly reported as error
+// * [ ] CommonJs modules correctly expose named exports
+// * [ ] require('module').createRequire API works as expected
+// * [ ] Fallback service works as expected
+// * [ ] console.log output correctly uses node-internal:inspect for output
+// ...

src/workerd/api/tests/new-module-registry-test.wd-test

@@ -0,0 +1,43 @@
+using Workerd = import "/workerd/workerd.capnp";
+
+const unitTests :Workerd.Config = (
+ services = [
+ ( name = "new-module-registry-test",
+ worker = (
+ modules = [
+ (name = "worker", esModule = embed "new-module-registry-test.js"),
+ (name = "foo", esModule = "export const foo = 1; export default 2; export const bar = import.meta.url"),
+ (name = "bar", esModule = "export const foo = 1; export default 2;"),
+ (name = "node:fs", esModule = "export default 'abc'"),
+
+ # Intentionally bad module to test error handling.
+ # Evaluation will error because i/o is not permitted at top-level scope.
+ (name = "bad", esModule = "export default 1; setTimeout(() => {}, 10)"),
+
+ # Ensure that async context is propagated into a dynamic import.
+ (name = "als", esModule = "export default globalThis.als.getStore()"),
+
+ # Import assertions are not supported currently
+ (name = "ia", esModule = "import * as def from 'foo' with { a: 'test' }"),
+
+ # Errors on ESM eval should be reported properly in both static and
+ # dynamic imports.
+ (name = "esm-error", esModule = "export default 1; throw new Error('boom');"),
+ (name = "esm-error-dynamic", esModule = "export * as d from 'esm-error'"),
+
+ # Other module types work
+ (name = "text", text = "abc"),
+ (name = "data", data = "abcdef"),
+ (name = "json", json = "{ \"foo\": 1 }"),
+ (name = "invalid-json", json = "1n"),
+ ],
+ compatibilityDate = "2024-07-01",
+ compatibilityFlags = [
+ "nodejs_compat_v2",
+ "new_module_registry",
+ "experimental",
+ ],
+ )
+ ),
+ ],
+);