prog

Author: jsantell

Cargo.lock

@@ -59,8 +59,8 @@ rand = { version = "0.8" }
 redb = { version = "2" }
 reqwest = { version = "0.12", default-features = false }
 #rust-embed = { version = "8.4" }
-#serde = { version = "1", features = ["derive"] }
-#serde_json = { version = "1" }
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1" }
 #sieve-cache = { version = "0.2" }
 #strum = { version = "0.26" }
 syn = { version = "2" }

Cargo.toml

@@ -19,6 +19,8 @@ deno_emit = { workspace = true }
 deno_graph = { workspace = true }
 redb = { workspace = true }
 reqwest = { workspace = true, default-features = false, features = ["rustls-tls", "charset", "http2", "macos-system-configuration"] }
+serde = { workspace = true }
+serde_json = { workspace = true }
 tempfile = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "io-util", "process", "fs"] }

rust/ct-builder/Cargo.toml

@@ -17,14 +17,18 @@ struct Cli {
     /// HTTP server port.
     #[arg(short = 'p', long, default_value_t = 8081)]
     pub http_port: u16,
+    /// HTTP server port.
+    #[arg(short = 'i', long)]
+    pub import_map: Option<std::path::PathBuf>,
 }
 
 #[cfg(not(target_arch = "wasm32"))]
 #[tokio::main]
 pub async fn main() -> Result<(), ct_builder::Error> {
     use clap::Parser;
-    use ct_builder::{serve, BuildServerConfig};
+    use ct_builder::{serve, BuildServerConfig, ImportMap};
     use std::net::SocketAddr;
+    use std::path::PathBuf;
     use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
     let subscriber = FmtSubscriber::builder()
@@ -44,9 +48,20 @@ pub async fn main() -> Result<(), ct_builder::Error> {
         info!("HTTP listening on {}", socket_address);
         tokio::net::TcpListener::bind(socket_address).await?
     };
-    let config = BuildServerConfig::default()
+    let mut config = BuildServerConfig::default()
         .with_grpc(grpc_listener)
         .with_http(http_listener);
+    if let Some(import_map_path) = cli.import_map {
+        let import_map_path = if import_map_path.is_relative() {
+            std::env::current_dir()?
+                .join(import_map_path)
+                .canonicalize()?
+        } else {
+            import_map_path
+        };
+        let import_map = ImportMap::from_path(import_map_path).await?;
+        config = config.with_import_map(import_map);
+    }
     serve(config).await?;
 
     Ok(())

rust/ct-builder/src/bin/builder.rs

@@ -2,7 +2,7 @@ use crate::{
     artifact::Artifact,
     error::Error,
     storage::{JsComponentStorage, PersistedHashStorage},
-    JavaScriptBundler,
+    ImportMap, JavaScriptBundler,
 };
 use async_trait::async_trait;
 use blake3::Hash;
@@ -17,6 +17,7 @@ use tonic::{Request, Response, Status};
 pub struct BuildComponentConfig {
     pub definition: ModuleDefinition,
     pub bundle_common_imports: bool,
+    pub import_map: Option<ImportMap>,
 }
 
 #[derive(Clone)]
@@ -33,7 +34,11 @@ impl Builder {
         info!("Building source: {:#?}", config.definition.source);
         let artifact = match config.definition.content_type {
             ContentType::JavaScript => {
-                JavaScriptBundler::bundle_from_bytes_sync(config.definition.source.into()).await?
+                JavaScriptBundler::bundle_from_bytes_sync(
+                    config.definition.source.into(),
+                    config.import_map,
+                )
+                .await?
             }
         };
         self.storage.write(artifact).await
@@ -61,6 +66,7 @@ impl BuilderProto for Builder {
             .build(BuildComponentConfig {
                 definition,
                 bundle_common_imports: false,
+                import_map: None,
             })
             .await?;
 

rust/ct-builder/src/builder.rs

@@ -1,6 +1,7 @@
 //! Utilities for compiling/bundling JavaScript into
 //! a single source.
 
+use crate::{artifact::Artifact, Error, ImportMap};
 use anyhow::anyhow;
 use deno_emit::{
     bundle, BundleOptions, BundleType, EmitOptions, LoadFuture, LoadOptions, Loader,
@@ -10,8 +11,6 @@ use deno_graph::source::LoadResponse;
 use reqwest::Client;
 use url::Url;
 
-use crate::{artifact::Artifact, Error};
-
 // Root module must have `.tsx` in order to be
 // interprete as Typescript/JSX.
 const ROOT_MODULE_URL: &str = "bundler:root.tsx";
@@ -20,13 +19,15 @@ const ROOT_MODULE_SCHEME: &str = "bundler";
 struct JavaScriptLoader {
     root: Option<Vec<u8>>,
     client: Client,
+    import_map: Option<ImportMap>,
 }
 
 impl JavaScriptLoader {
-    pub fn new(root: Option<Vec<u8>>) -> Self {
+    pub fn new(root: Option<Vec<u8>>, import_map: Option<ImportMap>) -> Self {
         Self {
             root,
             client: Client::new(),
+            import_map,
         }
     }
 }
@@ -35,8 +36,8 @@ impl Loader for JavaScriptLoader {
     fn load(&self, specifier: &ModuleSpecifier, _options: LoadOptions) -> LoadFuture {
         let root = self.root.clone();
         let client = self.client.clone();
+        let import_map = self.import_map.clone();
         let specifier = specifier.clone();
-
         debug!("Attempting to load '{}'", specifier);
 
         Box::pin(async move {
@@ -62,31 +63,55 @@ impl Loader for JavaScriptLoader {
                     let bytes = response.bytes().await?;
                     let content = bytes.to_vec().into();
 
+                    let maybe_headers = Some(
+                        headers
+                            .into_iter()
+                            .filter_map(|(h, v)| {
+                                h.map(|header| {
+                                    (
+                                        header.to_string(),
+                                        v.to_str().unwrap_or_default().to_string(),
+                                    )
+                                })
+                            })
+                            .collect(),
+                    );
+                    trace!("maybe_headers {:#?}", maybe_headers);
                     trace!("Loaded remote module: {}", String::from_utf8_lossy(&bytes));
                     Ok(Some(LoadResponse::Module {
                         content,
                         specifier,
-                        maybe_headers: Some(
-                            headers
-                                .into_iter()
-                                .filter_map(|(h, v)| {
-                                    h.map(|header| {
-                                        (
-                                            header.to_string(),
-                                            v.to_str().unwrap_or_default().to_string(),
-                                        )
-                                    })
-                                })
-                                .collect(),
-                        ),
+                        maybe_headers,
                     }))
                 }
                 "node" | "npm" => Err(anyhow!(
                     "Could not import '{specifier}'. Node.js and NPM modules are not supported."
                 )),
-                _ => Err(anyhow!(
-                    "Could not import '{specifier}'. Unrecognize specifier format.'"
-                )),
+                _ => {
+                    let specifier_str = specifier.to_string();
+                    debug!("Attempting to load {} from import map", specifier_str);
+                    if let Some(import_map) = import_map {
+                        if let Some(module_path) = import_map.get(&specifier_str) {
+                            let module_str = tokio::fs::read_to_string(module_path).await?;
+
+                            // `LoadResponse::Module` appears to require at least
+                            // *some* headers.
+                            let headers = Some(std::collections::HashMap::from([(
+                                "content-type".into(),
+                                "text/javascript".into(),
+                            )]));
+
+                            return Ok(Some(LoadResponse::Module {
+                                content: module_str.into_bytes().into(),
+                                specifier,
+                                maybe_headers: headers,
+                            }));
+                        }
+                    }
+                    Err(anyhow!(
+                        "Could not import '{specifier}'. Unrecognize specifier format.'"
+                    ))
+                }
             }
         })
     }
@@ -114,15 +139,21 @@ impl JavaScriptBundler {
     }
 
     /// Bundle a JavaScript module via URL.
-    pub async fn bundle_from_url(url: Url) -> Result<Artifact, Error> {
-        let mut loader = JavaScriptLoader::new(None);
+    pub async fn bundle_from_url(
+        url: Url,
+        import_map: Option<ImportMap>,
+    ) -> Result<Artifact, Error> {
+        let mut loader = JavaScriptLoader::new(None, import_map);
         let emit = bundle(url, &mut loader, None, Self::bundle_options()).await?;
         Ok(emit.into())
     }
 
     /// Bundle a JavaScript module from bytes.
-    pub async fn bundle_from_bytes(module: Vec<u8>) -> Result<Artifact, Error> {
-        let mut loader = JavaScriptLoader::new(Some(module));
+    pub async fn bundle_from_bytes(
+        module: Vec<u8>,
+        import_map: Option<ImportMap>,
+    ) -> Result<Artifact, Error> {
+        let mut loader = JavaScriptLoader::new(Some(module), import_map);
         let emit = bundle(
             Url::parse(ROOT_MODULE_URL).map_err(|error| Error::Internal(format!("{error}")))?,
             &mut loader,
@@ -136,18 +167,25 @@ impl JavaScriptBundler {
     /// Spawns a blocking bundle operation on a thread dedicated to blocking
     /// operations. This is needed in cases where bundling is taking place e.g.,
     /// within a web server.
-    pub async fn bundle_from_bytes_sync(source_code: Vec<u8>) -> Result<Artifact, Error> {
+    pub async fn bundle_from_bytes_sync(
+        source_code: Vec<u8>,
+        import_map: Option<ImportMap>,
+    ) -> Result<Artifact, Error> {
         tokio::task::spawn_blocking(move || {
-            tokio::runtime::Handle::current()
-                .block_on(JavaScriptBundler::bundle_from_bytes(source_code))
+            tokio::runtime::Handle::current().block_on(JavaScriptBundler::bundle_from_bytes(
+                source_code,
+                import_map,
+            ))
         })
         .await?
     }
 }
 
 #[cfg(test)]
 pub mod tests {
-    use crate::JavaScriptBundler;
+    use std::path::PathBuf;
+
+    use crate::{ImportMap, JavaScriptBundler};
     use anyhow::Result;
     use ct_test_fixtures::EsmTestServer;
     use ct_tracing::ct_tracing;
@@ -165,7 +203,7 @@ pub mod tests {
         let mut server = EsmTestServer::default();
         let addr = server.start().await?;
         let candidate = Url::parse(&format!("http://{}/math/index.js", addr))?;
-        let bundle = JavaScriptBundler::bundle_from_url(candidate).await?;
+        let bundle = JavaScriptBundler::bundle_from_url(candidate, None).await?;
 
         assert_math_bundle(&bundle.component);
 
@@ -178,7 +216,7 @@ pub mod tests {
         let mut server = EsmTestServer::default();
         let addr = server.start().await?;
         let candidate = Url::parse(&format!("http://{}/math/index.ts", addr))?;
-        let bundle = JavaScriptBundler::bundle_from_url(candidate).await?;
+        let bundle = JavaScriptBundler::bundle_from_url(candidate, None).await?;
 
         assert_math_bundle(&bundle.component);
 
@@ -195,7 +233,7 @@ pub mod tests {
 "#,
             addr
         );
-        let bundle = JavaScriptBundler::bundle_from_bytes(candidate.into()).await?;
+        let bundle = JavaScriptBundler::bundle_from_bytes(candidate.into(), None).await?;
 
         assert_math_bundle(&bundle.component);
 
@@ -212,7 +250,7 @@ export const add = function add(x: number, y: number): number {
 "#
         .to_string();
 
-        let bundle = JavaScriptBundler::bundle_from_bytes(candidate.into()).await?;
+        let bundle = JavaScriptBundler::bundle_from_bytes(candidate.into(), None).await?;
         assert!(bundle.component.contains("function add"));
 
         Ok(())
@@ -230,12 +268,30 @@ console.log(read, write);
 "#
         .to_string();
 
-        let bundle = JavaScriptBundler::bundle_from_bytes(candidate.into()).await?;
+        let bundle = JavaScriptBundler::bundle_from_bytes(candidate.into(), None).await?;
 
         assert!(bundle
             .component
             .contains("import { read, write } from \"common:io/state@0.0.1\""));
 
         Ok(())
     }
+
+    #[tokio::test]
+    #[ct_tracing]
+    async fn it_bundles_modules_from_import_map() -> Result<()> {
+        let fixtures_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures");
+        let import_map_path = fixtures_dir.join("imports.json");
+        let import_map = ImportMap::from_path(import_map_path).await?;
+        let candidate = r#"
+import { add } from "test:math";
+console.log(add(3, 5));
+"#
+        .to_string();
+
+        let bundle =
+            JavaScriptBundler::bundle_from_bytes(candidate.into(), Some(import_map)).await?;
+        assert!(bundle.component.contains("a + b"));
+        Ok(())
+    }
 }

rust/ct-builder/src/bundle.rs

@@ -3,6 +3,9 @@ use redb::{CommitError, DatabaseError, StorageError, TableError, TransactionErro
 use tokio::task::JoinError;
 use tracing::subscriber::SetGlobalDefaultError;
 
+/// [`std::result::Result`] type with [Error] /// as its error.
+pub type Result<T> = ::std::result::Result<T, Error>;
+
 /// Errors from various builder operations.
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
@@ -109,3 +112,9 @@ impl From<axum::http::StatusCode> for Error {
         Error::Internal(value.to_string())
     }
 }
+
+impl From<serde_json::Error> for Error {
+    fn from(value: serde_json::Error) -> Self {
+        Error::Internal(value.to_string())
+    }
+}