resolve_and_transform

Author: alshdavid

justfile

@@ -106,11 +106,12 @@ build-tsc:
 [no-cd]
 run *ARGS:
   just build
-  env NODE_OPTIONS="--conditions="source" --experimental-strip-types --no-warnings" npx mach {{ARGS}}
+  env NODE_OPTIONS="--conditions=source --import tsx" npx mach {{ARGS}}
 
 alias test-integration := integration-tests
 integration-tests *ARGS:
-  node --conditions="source" --experimental-strip-types --no-warnings ./testing/setup.ts {{ARGS}}
+  just build
+  node --conditions=source --import tsx ./testing/setup.ts {{ARGS}}
 
 alias test-unit := unit-tests
 unit-tests:

packages/mach/src/cmd/build/build.rs

@@ -6,18 +6,19 @@ use serde::Deserialize;
 use serde::Serialize;
 
 use super::super::MachOptions;
-use super::build_parse_config::parse_config;
+// use super::build_parse_config::parse_config;
 // use super::create_result::create_build_result;
 // use crate::platform::bundling::bundle;
 use crate::core::plugins::load_plugins;
-use crate::core::transformation::build_asset_graph;
+use crate::core::resolve_and_transform::resolve_and_transform;
 // use crate::public::AssetGraphSync;
 // use crate::public::AssetMap;
 // use crate::public::AssetMapSync;
 // use crate::public::BundleGraphSync;
 // use crate::public::BundleManifestSync;
 // use crate::public::BundleMapSync;
 use crate::public::Compilation;
+use crate::public::MachConfig;
 // use crate::public::DependencyMapSync;
 // use crate::rpc::Engine;
 // use crate::platform::emit::emit;
@@ -64,32 +65,43 @@ pub fn build(
   mach_options: MachOptions,
   options: BuildOptions,
 ) -> anyhow::Result<BuildResult> {
-  let config = parse_config(&options).map_err(|e| anyhow::anyhow!(e))?;
+  // let config = parse_config(&options).map_err(|e| anyhow::anyhow!(e))?;
 
   /*
     This is the bundler state. It is passed into
-    the bundling phases with read or write permissions
+    the bundling phases with read or write access
     depending on how that phase uses them
   */
-  let mut compilation = Compilation::new();
-  let adapter_map = mach_options.rpc_hosts;
+  let mut compilation = Compilation{
+    machrc: mach_options.config,
+    rpc_hosts: mach_options.rpc_hosts,
+    config: MachConfig {
+      threads: mach_options.threads,
+      entries: mach_options.entries,
+      project_root: mach_options.project_root,
+      env: mach_options.env,
+      out_folder: mach_options.out_folder,
+    },
+    asset_contents: Default::default(),
+    asset_graph: Default::default(),
+    plugins: Default::default(),
+  };
 
   /*
-    load_plugins() will read source the .machrc and will
-    fetch then initialize the referenced plugins
+    load_plugins() will read the Machrc and initialize the referenced plugins
   */
-  let plugins = load_plugins(&config, &config.machrc, &adapter_map)?;
+  load_plugins(&mut compilation)?;
 
   /*
     resolve_and_transform() build the AssetGraph.
 
     It does this by crawling the source files, identify import statements, modifying their contents
     (like removing TypeScript types) and looping until there are no more import statements to resolve.
   */
-  build_asset_graph(config.clone(), plugins.clone(), &mut compilation)
+  resolve_and_transform(&mut compilation)
     .map_err(|e| anyhow::anyhow!(e))?;
 
-  println!("{}", &compilation.asset_graph.into_dot(&config));
+  println!("{}", &compilation.asset_graph.into_dot(&compilation.config));
 
   Ok(BuildResult::default())
 

packages/mach/src/cmd/build/build_parse_config.rs

@@ -88,25 +88,18 @@ fn parse_machrc(file_path: PathBuf) -> Result<Machrc, String> {
   };
 
   let mut mach_config = Machrc {
-    is_default: false,
-    file_path,
-    engines: vec!["mach".to_string()],
     resolvers: None,
     transformers: None,
   };
 
-  let Ok(json_file) = fs::read_to_string(&mach_config.file_path) else {
+  let Ok(json_file) = fs::read_to_string(&file_path) else {
     return Err("Unable to read file".to_string());
   };
 
   let Ok(json) = serde_json::from_str::<serde_json::Value>(&json_file) else {
     return Err("Unable to parse json".to_string());
   };
 
-  if json_file.contains("\"node:") {
-    mach_config.engines.push("node".to_string());
-  }
-
   if let Some(resolvers_value) = json.get("resolvers") {
     let mut resolvers = Vec::<String>::new();
     let Some(resolvers_values) = resolvers_value.as_array() else {

packages/mach/src/cmd/build/mod.rs

@@ -1,5 +1,5 @@
 mod build;
-mod build_parse_config;
+// mod build_parse_config;
 mod create_result;
 // mod build_event;
 

packages/mach/src/cmd/mach.rs

@@ -1,17 +1,28 @@
-use crate::rpc::RpcHosts;
+use std::{collections::HashMap, path::PathBuf};
 
-#[derive(Clone)]
+use crate::{public::Machrc, rpc::RpcHosts};
+
+#[derive(Clone, Debug)]
 pub struct MachOptions {
   pub rpc_hosts: RpcHosts,
-  /// How many threads to use for compilation
   pub threads: usize,
+  pub entries: Vec<PathBuf>,
+  pub config: Machrc,
+  pub env: HashMap<String, String>,
+  pub out_folder: PathBuf,
+  pub project_root: PathBuf,
 }
 
 impl Default for MachOptions {
   fn default() -> Self {
     Self {
       rpc_hosts: Default::default(),
       threads: num_cpus::get(),
+      entries: Default::default(),
+      config: Default::default(),
+      env: Default::default(),
+      out_folder: Default::default(),
+      project_root: Default::default(),      
     }
   }
 }

packages/mach/src/core/mod.rs

@@ -3,5 +3,5 @@ pub mod config;
 // pub mod emit;
 // pub mod packaging;
 pub mod plugins;
-pub mod transformation;
+pub mod resolve_and_transform;
 pub mod request_tracker;

packages/mach/src/core/plugins/load_plugins.rs

@@ -1,7 +1,7 @@
+use std::sync::Arc;
+
 use anyhow;
 
-use super::PluginContainer;
-use super::PluginContainerSync;
 use crate::plugins::resolver_javascript::ResolverJavaScript;
 use crate::plugins::resolver_rpc::ResolverAdapter;
 use crate::plugins::transformer_css::TransformerCSS;
@@ -10,54 +10,49 @@ use crate::plugins::transformer_html::TransformerHtml;
 use crate::plugins::transformer_javascript::TransformerJavaScript;
 use crate::plugins::transformer_json::TransformerJson;
 use crate::plugins::transformer_rpc::TransformerAdapter;
-use crate::public::MachConfig;
-use crate::public::Machrc;
+use crate::public::Compilation;
 use crate::public::Transformer;
-use crate::rpc::RpcHosts;
 
 pub fn load_plugins(
-  config: &MachConfig,
-  machrc: &Machrc,
-  adapter_map: &RpcHosts,
-) -> anyhow::Result<PluginContainerSync> {
-  let mut plugins = PluginContainer::default();
-
-  if let Some(resolvers) = &machrc.resolvers {
+  c: &mut Compilation,
+) -> anyhow::Result<()> {
+  if let Some(resolvers) = &c.machrc.resolvers {
     for plugin_string in resolvers {
-      let Some((engine, specifier)) = plugin_string.split_once(':') else {
-        return Err(anyhow::anyhow!(format!(
-          "Unable to parse engine:specifier for {}",
-          plugin_string
-        )));
-      };
-
-      if engine == "mach" && specifier == "resolver" {
-        plugins.resolvers.push(Box::new(ResolverJavaScript::new()));
-        continue;
+      match plugin_string.as_str() {
+        // Built-in
+        "mach:resolver" => {
+          c.plugins.resolvers.push(Arc::new(ResolverJavaScript::new()));
+          continue;
+        }
+        // External
+        specifier => {
+          let Some((engine, specifier)) = specifier.split_once(':') else {
+            return Err(anyhow::anyhow!(format!(
+              "Unable to parse engine:specifier for {}",
+              plugin_string
+            )));
+          };
+    
+          let Some(adapter) = c.rpc_hosts.get(engine) else {
+            return Err(anyhow::anyhow!(format!(
+              "No plugin runtime for engine: {}\nCannot load plugin: {}",
+              engine, specifier
+            )));
+          };
+    
+          c.plugins.resolvers.push(Arc::new(ResolverAdapter::new(
+            &c.config,
+            specifier,
+            adapter.clone(),
+          )?));
+        }
       }
-
-      let Some(adapter) = adapter_map.get(engine) else {
-        return Err(anyhow::anyhow!(format!(
-          "No plugin runtime for engine: {}\nCannot load plugin: {}",
-          engine, specifier
-        )));
-      };
-
-      adapter.start()?;
-
-      plugins.resolvers.push(Box::new(ResolverAdapter::new(
-        &*config,
-        specifier,
-        adapter.clone(),
-      )?));
-
-      continue;
     }
   }
 
-  if let Some(transformers) = &machrc.transformers {
+  if let Some(transformers) = &c.machrc.transformers {
     for (pattern, specifiers) in transformers {
-      let mut transformers = Vec::<Box<dyn Transformer>>::new();
+      let mut transformers = Vec::<Arc<dyn Transformer>>::new();
 
       for plugin_string in specifiers {
         let Some((engine, specifier)) = plugin_string.split_once(':') else {
@@ -67,31 +62,31 @@ pub fn load_plugins(
           )));
         };
         if engine == "mach" && specifier == "transformer/javascript" {
-          transformers.push(Box::new(TransformerJavaScript {}));
+          transformers.push(Arc::new(TransformerJavaScript {}));
           continue;
         }
 
         if engine == "mach" && specifier == "transformer/css" {
-          transformers.push(Box::new(TransformerCSS {}));
+          transformers.push(Arc::new(TransformerCSS {}));
           continue;
         }
 
         if engine == "mach" && specifier == "transformer/html" {
-          transformers.push(Box::new(TransformerHtml {}));
+          transformers.push(Arc::new(TransformerHtml {}));
           continue;
         }
 
         if engine == "mach" && specifier == "transformer/json" {
-          transformers.push(Box::new(TransformerJson {}));
+          transformers.push(Arc::new(TransformerJson {}));
           continue;
         }
 
         if engine == "mach" && specifier == "transformer/drop" {
-          transformers.push(Box::new(TransformerDrop {}));
+          transformers.push(Arc::new(TransformerDrop {}));
           continue;
         }
 
-        let Some(adapter) = adapter_map.get(engine) else {
+        let Some(adapter) = c.rpc_hosts.get(engine) else {
           return Err(anyhow::anyhow!(format!(
             "No plugin runtime for engine: {}\nCannot load plugin: {}",
             engine, specifier
@@ -100,18 +95,19 @@ pub fn load_plugins(
 
         adapter.start()?;
 
-        transformers.push(Box::new(TransformerAdapter::new(
-          &*config,
+        transformers.push(Arc::new(TransformerAdapter::new(
+          &c.config,
           specifier,
           adapter.clone(),
         )?));
       }
 
-      plugins
+      c.plugins
         .transformers
         .transformers
         .insert(pattern.clone(), transformers);
     }
   }
-  return Ok(plugins.to_sync());
+  
+  return Ok(());
 }

packages/mach/src/core/plugins/plugin_container.rs

@@ -7,34 +7,28 @@ use crate::public::Transformer;
 
 pub type PluginContainerSync = Arc<PluginContainer>;
 
-#[derive(Default, Debug)]
+#[derive(Clone, Default, Debug)]
 pub struct PluginContainer {
-  pub resolvers: Vec<Box<dyn Resolver>>,
+  pub resolvers: Vec<Arc<dyn Resolver>>,
   pub transformers: TransformerMap,
 }
 
-impl PluginContainer {
-  pub fn to_sync(&mut self) -> PluginContainerSync {
-    Arc::new(std::mem::take(self))
-  }
-}
-
-#[derive(Default, Debug)]
+#[derive(Clone, Default, Debug)]
 pub struct TransformerMap {
-  pub transformers: HashMap<String, Vec<Box<dyn Transformer>>>,
+  pub transformers: HashMap<String, Vec<Arc<dyn Transformer>>>,
 }
 
 impl TransformerMap {
   pub fn get(
     &self,
     file_target: &TransformerTarget,
-  ) -> Result<(String, &Vec<Box<dyn Transformer>>), String> {
+  ) -> anyhow::Result<(String, &Vec<Arc<dyn Transformer>>)> {
     for (pattern, transformers) in &self.transformers {
       if glob_match::glob_match(&pattern, &file_target.file_name) {
         return Ok((pattern.clone(), transformers));
       }
     }
-    return Err(format!("No transformer found {:?}", file_target.file_path,));
+    anyhow::bail!("No transformer found {:?}", file_target.file_path)
   }
 }
 

packages/mach/src/core/resolve_and_transform/mod.rs

@@ -0,0 +1,5 @@
+mod resolve_and_transform;
+mod run_resolvers;
+mod run_transformers;
+
+pub use self::resolve_and_transform::*;