feat: add --require run arg to support commonJS

Author: fraidev

cli/args/flags.rs

@@ -806,6 +806,7 @@ pub struct Flags {
   pub eszip: bool,
   pub node_conditions: Vec<String>,
   pub preload: Vec<String>,
+  pub require: Vec<String>,
   pub tunnel: bool,
 }
 
@@ -4159,6 +4160,7 @@ fn compile_args_without_check_args(app: Command) -> Command {
     .arg(ca_file_arg())
     .arg(unsafely_ignore_certificate_errors_arg())
     .arg(preload_arg())
+    .arg(require_arg())
     .arg(min_dep_age_arg())
 }
 
@@ -4749,6 +4751,15 @@ fn preload_arg() -> Arg {
     .value_hint(ValueHint::FilePath)
 }
 
+fn require_arg() -> Arg {
+  Arg::new("require")
+    .long("require")
+    .value_name("FILE")
+    .action(ArgAction::Append)
+    .help("A list of CommonJS modules that will be executed before the main module (even if it's not with a .cjs or .tjs extension)")
+    .value_hint(ValueHint::FilePath)
+}
+
 fn min_dep_age_arg() -> Arg {
   Arg::new("minimum-dependency-age")
     .long("minimum-dependency-age")
@@ -6511,6 +6522,7 @@ fn compile_args_without_check_parse(
   ca_file_arg_parse(flags, matches);
   unsafely_ignore_certificate_errors_parse(flags, matches);
   preload_arg_parse(flags, matches);
+  require_arg_parse(flags, matches);
   min_dep_age_arg_parse(flags, matches);
   Ok(())
 }
@@ -6789,6 +6801,12 @@ fn preload_arg_parse(flags: &mut Flags, matches: &mut ArgMatches) {
   }
 }
 
+fn require_arg_parse(flags: &mut Flags, matches: &mut ArgMatches) {
+  if let Some(require) = matches.remove_many::<String>("require") {
+    flags.require = require.collect();
+  }
+}
+
 fn min_dep_age_arg_parse(flags: &mut Flags, matches: &mut ArgMatches) {
   flags.minimum_dependency_age = matches.remove_one("minimum-dependency-age");
 }
@@ -13464,6 +13482,53 @@ Usage: deno repl [OPTIONS] [-- [ARGS]...]\n"
     );
   }
 
+  #[test]
+  fn require_flag_test() {
+    let flags = flags_from_vec(svec![
+      "deno",
+      "run",
+      "--require",
+      "require.js",
+      "main.ts"
+    ])
+    .unwrap();
+    assert_eq!(
+      flags,
+      Flags {
+        subcommand: DenoSubcommand::Run(RunFlags {
+          script: "main.ts".into(),
+          ..Default::default()
+        }),
+        require: svec!["require.js"],
+        code_cache_enabled: true,
+        ..Default::default()
+      }
+    );
+
+    let flags = flags_from_vec(svec![
+      "deno",
+      "run",
+      "--require",
+      "r1.js",
+      "--require",
+      "./r2.js",
+      "main.ts"
+    ])
+    .unwrap();
+    assert_eq!(
+      flags,
+      Flags {
+        subcommand: DenoSubcommand::Run(RunFlags {
+          script: "main.ts".into(),
+          ..Default::default()
+        }),
+        require: svec!["r1.js", "./r2.js"],
+        code_cache_enabled: true,
+        ..Default::default()
+      }
+    );
+  }
+
   #[test]
   fn check_with_v8_flags() {
     let flags =

cli/args/mod.rs

@@ -5,6 +5,7 @@ mod flags_net;
 
 use std::borrow::Cow;
 use std::collections::HashMap;
+use std::collections::HashSet;
 use std::env;
 use std::net::SocketAddr;
 use std::num::NonZeroUsize;
@@ -637,17 +638,50 @@ impl CliOptions {
     self.flags.env_file.as_ref()
   }
 
+  /// Returns preload/import modules and require modules
+  pub fn all_preload_modules(&self) -> Result<Vec<ModuleSpecifier>, AnyError> {
+    if self.flags.preload.is_empty() && self.flags.require.is_empty() {
+      return Ok(vec![]);
+    }
+
+    let mut modules = HashSet::new();
+    for preload_specifier in self.flags.preload.iter() {
+      modules
+        .insert(resolve_url_or_path(preload_specifier, self.initial_cwd())?);
+    }
+
+    for require_specifier in self.flags.require.iter() {
+      modules
+        .insert(resolve_url_or_path(require_specifier, self.initial_cwd())?);
+    }
+
+    Ok(modules.into_iter().collect())
+  }
+
   pub fn preload_modules(&self) -> Result<Vec<ModuleSpecifier>, AnyError> {
     if self.flags.preload.is_empty() {
       return Ok(vec![]);
     }
 
-    let mut preload = Vec::with_capacity(self.flags.preload.len());
+    let mut modules = Vec::with_capacity(self.flags.preload.len());
     for preload_specifier in self.flags.preload.iter() {
-      preload.push(resolve_url_or_path(preload_specifier, self.initial_cwd())?);
+      modules.push(resolve_url_or_path(preload_specifier, self.initial_cwd())?);
+    }
+
+    Ok(modules)
+  }
+
+  pub fn require_modules(&self) -> Result<Vec<ModuleSpecifier>, AnyError> {
+    if self.flags.require.is_empty() {
+      return Ok(vec![]);
+    }
+
+    let mut require = Vec::with_capacity(self.flags.require.len());
+    for require_specifier in self.flags.require.iter() {
+      require.push(resolve_url_or_path(require_specifier, self.initial_cwd())?);
     }
 
-    Ok(preload)
+    Ok(require)
   }
 
   fn resolve_main_module_with_resolver_if_bare(

cli/factory.rs

@@ -1271,6 +1271,7 @@ impl CliFactory {
           } else {
             deno_resolver::loader::AllowJsonImports::WithAttribute
           },
+          require_modules: options.require_modules().unwrap_or_default(),
         },
       )))
     })

cli/lib/standalone/binary.rs

@@ -87,6 +87,7 @@ pub struct Metadata {
   pub workspace_resolver: SerializedWorkspaceResolver,
   pub entrypoint_key: String,
   pub preload_modules: Vec<String>,
+  pub require_modules: Vec<String>,
   pub node_modules: Option<NodeModules>,
   pub unstable_config: UnstableConfig,
   pub otel_config: OtelConfig,

cli/lsp/config.rs

@@ -1469,6 +1469,7 @@ impl ConfigData {
         specified_import_map: None,
         types_node_version_req: Some(crate::npm::get_types_node_version_req()),
         unstable_sloppy_imports: false,
+        require_modules: vec![],
       },
     );
     let pb = ProgressBar::new(ProgressBarStyle::TextOnly);

cli/rt/run.rs

@@ -849,6 +849,11 @@ pub async fn run(
     node_resolution_sys,
     node_resolver::NodeResolverOptions::default(),
   ));
+  let require_modules = metadata
+    .require_modules
+    .iter()
+    .map(|key| root_dir_url.join(key).unwrap())
+    .collect::<Vec<_>>();
   let cjs_tracker = Arc::new(CjsTracker::new(
     in_npm_pkg_checker.clone(),
     pkg_json_resolver.clone(),
@@ -859,6 +864,7 @@ pub async fn run(
     } else {
       IsCjsResolutionMode::ExplicitTypeCommonJs
     },
+    require_modules,
   ));
   let npm_req_resolver = Arc::new(NpmReqResolver::new(NpmReqResolverOptions {
     sys: sys.clone(),
@@ -1077,12 +1083,20 @@ pub async fn run(
     Err(_) => main_module,
   };
 
-  let preload_modules = metadata
+  let mut preload_modules = metadata
     .preload_modules
     .iter()
     .map(|key| root_dir_url.join(key).unwrap())
     .collect::<Vec<_>>();
 
+  let require_modules = metadata
+    .require_modules
+    .iter()
+    .map(|key| root_dir_url.join(key).unwrap())
+    .collect::<Vec<_>>();
+
+  preload_modules.extend(require_modules);
+
   let mut worker = worker_factory.create_main_worker(
     WorkerExecutionMode::Run,
     permissions,

cli/standalone/binary.rs

@@ -723,6 +723,13 @@ impl<'a> DenoCompileBinaryWriter<'a> {
       .map(|s| root_dir_url.specifier_key(&s).into_owned())
       .collect::<Vec<_>>();
 
+    let require_modules = self
+      .cli_options
+      .require_modules()?
+      .into_iter()
+      .map(|s| root_dir_url.specifier_key(&s).into_owned())
+      .collect::<Vec<_>>();
+
     let metadata = Metadata {
       argv: compile_flags.args.clone(),
       seed: self.cli_options.seed(),
@@ -744,6 +751,7 @@ impl<'a> DenoCompileBinaryWriter<'a> {
       env_vars_from_env_file,
       entrypoint_key: root_dir_url.specifier_key(entrypoint).into_owned(),
       preload_modules,
+      require_modules,
       workspace_resolver: SerializedWorkspaceResolver {
         import_map: self.workspace_resolver.maybe_import_map().map(|i| {
           SerializedWorkspaceResolverImportMap {

cli/tools/bench/mod.rs

@@ -498,7 +498,7 @@ pub async fn run_benchmarks(
     return Ok(());
   }
 
-  let preload_modules = cli_options.preload_modules()?;
+  let preload_modules = cli_options.all_preload_modules()?;
   let log_level = cli_options.log_level();
   let worker_factory =
     Arc::new(factory.create_cli_main_worker_factory().await?);
@@ -636,7 +636,7 @@ pub async fn run_benchmarks_with_watch(
         }
 
         let log_level = cli_options.log_level();
-        let preload_modules = cli_options.preload_modules()?;
+        let preload_modules = cli_options.all_preload_modules()?;
         bench_specifiers(
           worker_factory,
           cli_options,

cli/tools/compile.rs

@@ -436,7 +436,7 @@ fn get_module_roots_and_include_paths(
     }
   }
 
-  for preload_module in cli_options.preload_modules()? {
+  for preload_module in cli_options.all_preload_modules()? {
     module_roots.push(preload_module);
   }
 

cli/tools/run/mod.rs

@@ -90,7 +90,7 @@ pub async fn run_script(
       node_resolver.clone(),
     ),
   ))?;
-  let preload_modules = cli_options.preload_modules()?;
+  let preload_modules = cli_options.all_preload_modules()?;
 
   if main_module.scheme() == "npm" {
     set_npm_user_agent();
@@ -126,7 +126,7 @@ pub async fn run_from_stdin(
   let factory = CliFactory::from_flags(flags);
   let cli_options = factory.cli_options()?;
   let main_module = cli_options.resolve_main_module()?;
-  let preload_modules = cli_options.preload_modules()?;
+  let preload_modules = cli_options.all_preload_modules()?;
 
   maybe_npm_install(&factory).await?;
 
@@ -190,7 +190,7 @@ async fn run_with_watch(
         );
         let cli_options = factory.cli_options()?;
         let main_module = cli_options.resolve_main_module()?;
-        let preload_modules = cli_options.preload_modules()?;
+        let preload_modules = cli_options.all_preload_modules()?;
 
         if main_module.scheme() == "npm" {
           set_npm_user_agent();
@@ -230,7 +230,7 @@ pub async fn eval_command(
   let cli_options = factory.cli_options()?;
   let file_fetcher = factory.file_fetcher()?;
   let main_module = cli_options.resolve_main_module()?;
-  let preload_modules = cli_options.preload_modules()?;
+  let preload_modules = cli_options.all_preload_modules()?;
 
   maybe_npm_install(&factory).await?;
 
@@ -307,7 +307,7 @@ pub async fn run_eszip(
 
   let mode = WorkerExecutionMode::Run;
   let main_module = resolve_url_or_path(entrypoint, cli_options.initial_cwd())?;
-  let preload_modules = cli_options.preload_modules()?;
+  let preload_modules = cli_options.all_preload_modules()?;
 
   let worker_factory = factory
     .create_cli_main_worker_factory_with_roots(roots)