feat: Add support for import assertions and JSON modules (#12866)

This commit adds proper support for import assertions and JSON modules.

Implementation of "core/modules.rs" was changed to account for multiple possible
module types, instead of always assuming that the code is an "ES module". In
effect "ModuleMap" now has knowledge about each modules' type (stored via
"ModuleType" enum). Module loading pipeline now stores information about
expected module type for each request and validates that expected type matches
discovered module type based on file's "MediaType".

Relevant tests were added to "core/modules.rs" and integration tests,
additionally multiple WPT tests were enabled.

There are still some rough edges in the implementation and not all WPT were
enabled, due to:
a) unclear BOM handling in source code by "FileFetcher"
b) design limitation of Deno's "FileFetcher" that doesn't download the same
module multiple times in a single run

Co-authored-by: Kitson Kelly <[email protected]>

cli/config_file.rs

@@ -104,6 +104,7 @@ pub const IGNORED_COMPILER_OPTIONS: &[&str] = &[
   "paths",
   "preserveConstEnums",
   "reactNamespace",
+  "resolveJsonModule",
   "rootDir",
   "rootDirs",
   "skipLibCheck",

cli/emit.rs

@@ -153,6 +153,7 @@ pub(crate) fn get_ts_config(
         "isolatedModules": true,
         "lib": lib,
         "module": "esnext",
+        "resolveJsonModule": true,
         "strict": true,
         "target": "esnext",
         "tsBuildInfoFile": "deno:///.tsbuildinfo",
@@ -186,6 +187,7 @@ pub(crate) fn get_ts_config(
       "jsx": "react",
       "jsxFactory": "React.createElement",
       "jsxFragmentFactory": "React.Fragment",
+      "resolveJsonModule": true,
     })),
     ConfigType::RuntimeEmit { tsc_emit } => {
       let mut ts_config = TsConfig::new(json!({
@@ -403,14 +405,15 @@ pub(crate) fn check_and_maybe_emit(
           log::debug!("module missing, skipping emit for {}", specifier);
           continue;
         };
-        // Sometimes if `tsc` sees a CommonJS file it will _helpfully_ output it
-        // to ESM, which we don't really want to do unless someone has enabled
-        // check_js.
-        if !check_js
-          && matches!(
-            media_type,
-            MediaType::JavaScript | MediaType::Cjs | MediaType::Mjs
-          )
+        // Sometimes if `tsc` sees a CommonJS file or a JSON module, it will
+        // _helpfully_ output it, which we don't really want to do unless
+        // someone has enabled check_js.
+        if matches!(media_type, MediaType::Json)
+          || (!check_js
+            && matches!(
+              media_type,
+              MediaType::JavaScript | MediaType::Cjs | MediaType::Mjs
+            ))
         {
           log::debug!("skipping emit for {}", specifier);
           continue;
@@ -429,7 +432,10 @@ pub(crate) fn check_and_maybe_emit(
           MediaType::Dts | MediaType::Dcts | MediaType::Dmts => {
             cache.set(CacheType::Declaration, &specifier, emit.data)?;
           }
-          _ => unreachable!(),
+          _ => unreachable!(
+            "unexpected media_type {} {}",
+            emit.media_type, specifier
+          ),
         }
       }
     }

cli/lsp/language_server.rs

@@ -569,6 +569,7 @@ impl Inner {
       "lib": ["deno.ns", "deno.window"],
       "module": "esnext",
       "noEmit": true,
+      "resolveJsonModule": true,
       "strict": true,
       "target": "esnext",
       "useDefineForClassFields": true,

cli/proc_state.rs

@@ -31,6 +31,7 @@ use deno_core::url::Url;
 use deno_core::CompiledWasmModuleStore;
 use deno_core::ModuleSource;
 use deno_core::ModuleSpecifier;
+use deno_core::ModuleType;
 use deno_core::SharedArrayBufferStore;
 use deno_graph::create_graph;
 use deno_graph::Dependency;
@@ -68,6 +69,7 @@ pub struct ProcState(Arc<Inner>);
 enum ModuleEntry {
   Module {
     code: String,
+    media_type: MediaType,
     dependencies: BTreeMap<String, Dependency>,
   },
   Error(ModuleGraphError),
@@ -584,6 +586,7 @@ impl ProcState {
                 | MediaType::Unknown
                 | MediaType::Cjs
                 | MediaType::Mjs
+                | MediaType::Json
             ) {
               module.maybe_source().unwrap_or("").to_string()
             // The emit may also be missing when a declaration file is in the
@@ -602,7 +605,11 @@ impl ProcState {
               module.maybe_dependencies().cloned().unwrap_or_default();
             graph_data.modules.insert(
               specifier.clone(),
-              ModuleEntry::Module { code, dependencies },
+              ModuleEntry::Module {
+                code,
+                dependencies,
+                media_type: *media_type,
+              },
             );
             if let Some(dependencies) = module.maybe_dependencies() {
               for dep in dependencies.values() {
@@ -724,10 +731,16 @@ impl ProcState {
       _ => &specifier,
     };
     match graph_data.modules.get(found_specifier) {
-      Some(ModuleEntry::Module { code, .. }) => Ok(ModuleSource {
+      Some(ModuleEntry::Module {
+        code, media_type, ..
+      }) => Ok(ModuleSource {
         code: code.clone(),
         module_url_specified: specifier.to_string(),
         module_url_found: found_specifier.to_string(),
+        module_type: match media_type {
+          MediaType::Json => ModuleType::Json,
+          _ => ModuleType::JavaScript,
+        },
       }),
       _ => Err(anyhow!(
         "Loading unprepared module: {}",

cli/standalone.rs

@@ -164,6 +164,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
 
       Ok(deno_core::ModuleSource {
         code,
+        module_type: deno_core::ModuleType::JavaScript,
         module_url_specified: module_specifier.to_string(),
         module_url_found: module_specifier.to_string(),
       })

cli/tests/integration/run_tests.rs

@@ -2407,3 +2407,36 @@ fn issue12807() {
     .unwrap();
   assert!(status.success());
 }
+
+itest!(import_assertions_static_import {
+  args: "run --allow-read import_assertions/static_import.ts",
+  output: "import_assertions/static_import.out",
+});
+
+itest!(import_assertions_static_export {
+  args: "run --allow-read import_assertions/static_export.ts",
+  output: "import_assertions/static_export.out",
+});
+
+itest!(import_assertions_static_error {
+  args: "run --allow-read import_assertions/static_error.ts",
+  output: "import_assertions/static_error.out",
+  exit_code: 1,
+});
+
+itest!(import_assertions_dynamic_import {
+  args: "run --allow-read import_assertions/dynamic_import.ts",
+  output: "import_assertions/dynamic_import.out",
+});
+
+itest!(import_assertions_dynamic_error {
+  args: "run --allow-read import_assertions/dynamic_error.ts",
+  output: "import_assertions/dynamic_error.out",
+  exit_code: 1,
+});
+
+itest!(import_assertions_type_check {
+  args: "run --allow-read import_assertions/type_check.ts",
+  output: "import_assertions/type_check.out",
+  exit_code: 1,
+});

cli/tests/testdata/import_assertions/data.json

@@ -0,0 +1,6 @@
+{
+  "a": "b",
+  "c": {
+    "d": 10
+  }
+}

cli/tests/testdata/import_assertions/dynamic_error.out

@@ -0,0 +1,5 @@
+[WILDCARD]
+error: Uncaught (in promise) TypeError: Expected a "JavaScript" module but loaded a "JSON" module.
+const data = await import("./data.json");
+             ^
+    at async [WILDCARD]dynamic_error.ts:1:14

cli/tests/testdata/import_assertions/dynamic_error.ts

@@ -0,0 +1,3 @@
+const data = await import("./data.json");
+
+console.log(data);

cli/tests/testdata/import_assertions/dynamic_import.out

@@ -0,0 +1,2 @@
+[WILDCARD]
+Module { default: { a: "b", c: { d: 10 } } }

cli/tests/testdata/import_assertions/dynamic_import.ts

@@ -0,0 +1,3 @@
+const data = await import("./data.json", { assert: { type: "json" } });
+
+console.log(data);

cli/tests/testdata/import_assertions/static_error.out

@@ -0,0 +1,5 @@
+[WILDCARD]
+error: An unsupported media type was attempted to be imported as a module.
+  Specifier: [WILDCARD]data.json
+  MediaType: Json
+    at [WILDCARD]static_error.ts:1:18

cli/tests/testdata/import_assertions/static_error.ts

@@ -0,0 +1,3 @@
+import data from "./data.json";
+
+console.log(data);

cli/tests/testdata/import_assertions/static_export.out

@@ -0,0 +1,2 @@
+[WILDCARD]
+{ a: "b", c: { d: 10 } }

cli/tests/testdata/import_assertions/static_export.ts

@@ -0,0 +1,3 @@
+import data from "./static_reexport.ts";
+
+console.log(data);

cli/tests/testdata/import_assertions/static_import.out

@@ -0,0 +1,2 @@
+[WILDCARD]
+{ a: "b", c: { d: 10 } }

cli/tests/testdata/import_assertions/static_import.ts

@@ -0,0 +1,3 @@
+import data from "./data.json" assert { type: "json" };
+
+console.log(data);

cli/tests/testdata/import_assertions/static_reexport.ts

@@ -0,0 +1 @@
+export { default } from "./data.json" assert { type: "json" };

cli/tests/testdata/import_assertions/type_check.out

@@ -0,0 +1,5 @@
+[WILDCARD]
+error: TS2339 [ERROR]: Property 'foo' does not exist on type '{ a: string; c: { d: number; }; }'.
+console.log(data.foo);
+                 ~~~
+    at [WILDCARD]type_check.ts:3:18

cli/tests/testdata/import_assertions/type_check.ts

@@ -0,0 +1,3 @@
+import data from "./data.json" assert { type: "json" };
+
+console.log(data.foo);

cli/tsc.rs

@@ -352,6 +352,24 @@ struct LoadArgs {
   specifier: String,
 }
 
+fn as_ts_script_kind(media_type: &MediaType) -> i32 {
+  match media_type {
+    MediaType::JavaScript => 1,
+    MediaType::Jsx => 2,
+    MediaType::Mjs => 1,
+    MediaType::Cjs => 1,
+    MediaType::TypeScript => 3,
+    MediaType::Mts => 3,
+    MediaType::Cts => 3,
+    MediaType::Dts => 3,
+    MediaType::Dmts => 3,
+    MediaType::Dcts => 3,
+    MediaType::Tsx => 4,
+    MediaType::Json => 6,
+    _ => 0,
+  }
+}
+
 fn op_load(state: &mut State, args: Value) -> Result<Value, AnyError> {
   let v: LoadArgs = serde_json::from_value(args)
     .context("Invalid request from JavaScript for \"op_load\".")?;
@@ -395,7 +413,7 @@ fn op_load(state: &mut State, args: Value) -> Result<Value, AnyError> {
   };
 
   Ok(
-    json!({ "data": data, "hash": hash, "scriptKind": media_type.as_ts_script_kind() }),
+    json!({ "data": data, "hash": hash, "scriptKind": as_ts_script_kind(&media_type) }),
   )
 }
 

core/bindings.rs

@@ -1,6 +1,10 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 
 use crate::error::is_instance_of_error;
+use crate::modules::get_module_type_from_assertions;
+use crate::modules::parse_import_assertions;
+use crate::modules::validate_import_assertions;
+use crate::modules::ImportAssertionsKind;
 use crate::modules::ModuleMap;
 use crate::resolve_url_or_path;
 use crate::JsRuntime;
@@ -243,7 +247,7 @@ pub extern "C" fn host_import_module_dynamically_callback(
   context: v8::Local<v8::Context>,
   referrer: v8::Local<v8::ScriptOrModule>,
   specifier: v8::Local<v8::String>,
-  _import_assertions: v8::Local<v8::FixedArray>,
+  import_assertions: v8::Local<v8::FixedArray>,
 ) -> *mut v8::Promise {
   let scope = &mut unsafe { v8::CallbackScope::new(context) };
 
@@ -267,6 +271,22 @@ pub extern "C" fn host_import_module_dynamically_callback(
   let resolver = v8::PromiseResolver::new(scope).unwrap();
   let promise = resolver.get_promise(scope);
 
+  let assertions = parse_import_assertions(
+    scope,
+    import_assertions,
+    ImportAssertionsKind::DynamicImport,
+  );
+
+  {
+    let tc_scope = &mut v8::TryCatch::new(scope);
+    validate_import_assertions(tc_scope, &assertions);
+    if tc_scope.has_caught() {
+      let e = tc_scope.exception().unwrap();
+      resolver.reject(tc_scope, e);
+    }
+  }
+  let module_type = get_module_type_from_assertions(&assertions);
+
   let resolver_handle = v8::Global::new(scope, resolver);
   {
     let state_rc = JsRuntime::state(scope);
@@ -280,6 +300,7 @@ pub extern "C" fn host_import_module_dynamically_callback(
       module_map_rc,
       &specifier_str,
       &referrer_name_str,
+      module_type,
       resolver_handle,
     );
     state_rc.borrow_mut().notify_new_dynamic_import();
@@ -294,13 +315,29 @@ pub extern "C" fn host_import_module_dynamically_callback(
                  _rv: v8::ReturnValue| {
     let arg = args.get(0);
     if is_instance_of_error(scope, arg) {
+      let e: crate::error::NativeJsError =
+        serde_v8::from_v8(scope, arg).unwrap();
+      let name = e.name.unwrap_or_else(|| "Error".to_string());
       let message = v8::Exception::create_message(scope, arg);
       if message.get_stack_trace(scope).unwrap().get_frame_count() == 0 {
         let arg: v8::Local<v8::Object> = arg.try_into().unwrap();
         let message_key = v8::String::new(scope, "message").unwrap();
         let message = arg.get(scope, message_key.into()).unwrap();
-        let exception =
-          v8::Exception::type_error(scope, message.try_into().unwrap());
+        let exception = match name.as_str() {
+          "RangeError" => {
+            v8::Exception::range_error(scope, message.try_into().unwrap())
+          }
+          "TypeError" => {
+            v8::Exception::type_error(scope, message.try_into().unwrap())
+          }
+          "SyntaxError" => {
+            v8::Exception::syntax_error(scope, message.try_into().unwrap())
+          }
+          "ReferenceError" => {
+            v8::Exception::reference_error(scope, message.try_into().unwrap())
+          }
+          _ => v8::Exception::error(scope, message.try_into().unwrap()),
+        };
         let code_key = v8::String::new(scope, "code").unwrap();
         let code_value =
           v8::String::new(scope, "ERR_MODULE_NOT_FOUND").unwrap();
@@ -1311,7 +1348,7 @@ fn create_host_object(
 pub fn module_resolve_callback<'s>(
   context: v8::Local<'s, v8::Context>,
   specifier: v8::Local<'s, v8::String>,
-  _import_assertions: v8::Local<'s, v8::FixedArray>,
+  import_assertions: v8::Local<'s, v8::FixedArray>,
   referrer: v8::Local<'s, v8::Module>,
 ) -> Option<v8::Local<'s, v8::Module>> {
   let scope = &mut unsafe { v8::CallbackScope::new(context) };
@@ -1328,8 +1365,17 @@ pub fn module_resolve_callback<'s>(
 
   let specifier_str = specifier.to_rust_string_lossy(scope);
 
-  let maybe_module =
-    module_map.resolve_callback(scope, &specifier_str, &referrer_name);
+  let assertions = parse_import_assertions(
+    scope,
+    import_assertions,
+    ImportAssertionsKind::StaticImport,
+  );
+  let maybe_module = module_map.resolve_callback(
+    scope,
+    &specifier_str,
+    &referrer_name,
+    assertions,
+  );
   if let Some(module) = maybe_module {
     return Some(module);
   }

core/error.rs

@@ -158,9 +158,9 @@ fn get_property<'a>(
 }
 
 #[derive(serde::Deserialize)]
-struct NativeJsError {
-  name: Option<String>,
-  message: Option<String>,
+pub(crate) struct NativeJsError {
+  pub name: Option<String>,
+  pub message: Option<String>,
   // Warning! .stack is special so handled by itself
   // stack: Option<String>,
 }