chore: pass preload and require modules separately

Author: fraidev

cli/args/flags.rs

@@ -4756,7 +4756,9 @@ fn require_arg() -> Arg {
     .long("require")
     .value_name("FILE")
     .action(ArgAction::Append)
-    .help("A list of CommonJS modules that will be executed before the main module")
+    .help(
+      "A list of CommonJS modules that will be executed before the main module",
+    )
     .value_hint(ValueHint::FilePath)
 }
 

cli/args/mod.rs

@@ -57,7 +57,6 @@ use deno_semver::npm::NpmPackageReqReference;
 use deno_telemetry::OtelConfig;
 use deno_terminal::colors;
 pub use flags::*;
-use indexmap::IndexSet;
 use once_cell::sync::Lazy;
 use thiserror::Error;
 
@@ -638,26 +637,6 @@ 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 = IndexSet::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![]);

cli/lib/worker.rs

@@ -583,11 +583,13 @@ impl<TSys: DenoLibSys> LibMainWorkerFactory<TSys> {
     permissions: PermissionsContainer,
     main_module: Url,
     preload_modules: Vec<Url>,
+    require_modules: Vec<Url>,
   ) -> Result<LibMainWorker, CoreError> {
     self.create_custom_worker(
       mode,
       main_module,
       preload_modules,
+      require_modules,
       permissions,
       vec![],
       Default::default(),
@@ -602,6 +604,7 @@ impl<TSys: DenoLibSys> LibMainWorkerFactory<TSys> {
     mode: WorkerExecutionMode,
     main_module: Url,
     preload_modules: Vec<Url>,
+    require_modules: Vec<Url>,
     permissions: PermissionsContainer,
     custom_extensions: Vec<Extension>,
     stdio: deno_runtime::deno_io::Stdio,
@@ -724,6 +727,7 @@ impl<TSys: DenoLibSys> LibMainWorkerFactory<TSys> {
     Ok(LibMainWorker {
       main_module,
       preload_modules,
+      require_modules,
       worker,
     })
   }
@@ -811,6 +815,7 @@ impl<TSys: DenoLibSys> LibMainWorkerFactory<TSys> {
 pub struct LibMainWorker {
   main_module: Url,
   preload_modules: Vec<Url>,
+  require_modules: Vec<Url>,
   worker: MainWorker,
 }
 
@@ -878,6 +883,11 @@ impl LibMainWorker {
       self.worker.evaluate_module(id).await?;
       self.worker.run_event_loop(false).await?;
     }
+    for require_module_url in self.require_modules.iter() {
+      let id = self.worker.preload_side_module(require_module_url).await?;
+      self.worker.evaluate_module(id).await?;
+      self.worker.run_event_loop(false).await?;
+    }
     Ok(())
   }
 

cli/lsp/testing/execution.rs

@@ -323,6 +323,8 @@ impl TestRun {
             specifier,
             // Executing tests in the LSP currently doesn't support preload option
             vec![],
+            // Executing tests in the LSP currently doesn't support require option
+            vec![],
             worker_sender,
             fail_fast_tracker,
             test::TestSpecifierOptions {

cli/rt/run.rs

@@ -1083,7 +1083,7 @@ pub async fn run(
     Err(_) => main_module,
   };
 
-  let mut preload_modules = metadata
+  let preload_modules = metadata
     .preload_modules
     .iter()
     .map(|key| root_dir_url.join(key).unwrap())
@@ -1095,13 +1095,12 @@ pub async fn run(
     .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,
     main_module,
     preload_modules,
+    require_modules,
   )?;
 
   let exit_code = worker.run().await?;

cli/tools/bench/mod.rs

@@ -157,6 +157,7 @@ async fn bench_specifier(
   permissions_container: PermissionsContainer,
   specifier: ModuleSpecifier,
   preload_modules: Vec<ModuleSpecifier>,
+  require_modules: Vec<ModuleSpecifier>,
   sender: UnboundedSender<BenchEvent>,
   filter: TestFilter,
 ) -> Result<(), AnyError> {
@@ -165,6 +166,7 @@ async fn bench_specifier(
     permissions_container,
     specifier.clone(),
     preload_modules,
+    require_modules,
     &sender,
     filter,
   )
@@ -188,6 +190,7 @@ async fn bench_specifier_inner(
   permissions_container: PermissionsContainer,
   specifier: ModuleSpecifier,
   preload_modules: Vec<ModuleSpecifier>,
+  require_modules: Vec<ModuleSpecifier>,
   sender: &UnboundedSender<BenchEvent>,
   filter: TestFilter,
 ) -> Result<(), CreateCustomWorkerError> {
@@ -196,6 +199,7 @@ async fn bench_specifier_inner(
       WorkerExecutionMode::Bench,
       specifier.clone(),
       preload_modules,
+      require_modules,
       permissions_container,
       vec![ops::bench::deno_bench::init(sender.clone())],
       Default::default(),
@@ -301,6 +305,7 @@ async fn bench_specifiers(
   permission_desc_parser: &Arc<RuntimePermissionDescriptorParser<CliSys>>,
   specifiers: Vec<ModuleSpecifier>,
   preload_modules: Vec<ModuleSpecifier>,
+  require_modules: Vec<ModuleSpecifier>,
   options: BenchSpecifierOptions,
 ) -> Result<(), AnyError> {
   let (sender, mut receiver) = unbounded_channel::<BenchEvent>();
@@ -313,6 +318,7 @@ async fn bench_specifiers(
     let sender = sender.clone();
     let options = option_for_handles.clone();
     let preload_modules = preload_modules.clone();
+    let require_modules = require_modules.clone();
     let cli_options = cli_options.clone();
     let permission_desc_parser = permission_desc_parser.clone();
     spawn_blocking(move || {
@@ -333,6 +339,7 @@ async fn bench_specifiers(
         permissions_container,
         specifier,
         preload_modules,
+        require_modules,
         sender,
         options.filter,
       );
@@ -498,7 +505,8 @@ pub async fn run_benchmarks(
     return Ok(());
   }
 
-  let preload_modules = cli_options.all_preload_modules()?;
+  let preload_modules = cli_options.preload_modules()?;
+  let require_modules = cli_options.require_modules()?;
   let log_level = cli_options.log_level();
   let worker_factory =
     Arc::new(factory.create_cli_main_worker_factory().await?);
@@ -508,6 +516,7 @@ pub async fn run_benchmarks(
     factory.permission_desc_parser()?,
     specifiers,
     preload_modules,
+    require_modules,
     BenchSpecifierOptions {
       filter: TestFilter::from_flag(&workspace_bench_options.filter),
       json: workspace_bench_options.json,
@@ -636,13 +645,15 @@ pub async fn run_benchmarks_with_watch(
         }
 
         let log_level = cli_options.log_level();
-        let preload_modules = cli_options.all_preload_modules()?;
+        let preload_modules = cli_options.preload_modules()?;
+        let require_modules = cli_options.require_modules()?;
         bench_specifiers(
           worker_factory,
           cli_options,
           factory.permission_desc_parser()?,
           specifiers,
           preload_modules,
+          require_modules,
           BenchSpecifierOptions {
             filter: TestFilter::from_flag(&workspace_bench_options.filter),
             json: workspace_bench_options.json,

cli/tools/compile.rs

@@ -436,10 +436,14 @@ fn get_module_roots_and_include_paths(
     }
   }
 
-  for preload_module in cli_options.all_preload_modules()? {
+  for preload_module in cli_options.preload_modules()? {
     module_roots.push(preload_module);
   }
 
+  for require_module in cli_options.require_modules()? {
+    module_roots.push(require_module);
+  }
+
   Ok((module_roots, include_paths))
 }
 

cli/tools/deploy.rs

@@ -61,6 +61,7 @@ pub async fn deploy(mut flags: Flags) -> Result<i32, AnyError> {
       WorkerExecutionMode::Deploy,
       specifier,
       vec![],
+      vec![],
       PermissionsContainer::allow_all(
         factory.permission_desc_parser()?.clone(),
       ),

cli/tools/jupyter/mod.rs

@@ -102,6 +102,8 @@ pub async fn kernel(
       main_module.clone(),
       // `deno jupyter` doesn't support preloading modules
       vec![],
+      // `deno jupyter` doesn't support require modules
+      vec![],
       permissions,
       vec![
         ops::jupyter::deno_jupyter::init(stdio_tx.clone()),

cli/tools/lint/plugins.rs

@@ -157,6 +157,8 @@ async fn create_plugin_runner_inner(
       main_module.clone(),
       // `deno lint` doesn't support preloading modules
       vec![],
+      // `deno lint` doesn't support require modules
+      vec![],
       permissions,
       vec![crate::ops::lint::deno_lint_ext::init(logger.clone())],
       Default::default(),