Merge pull request #220 from supabase/accept-module-code

fix: Support module_code for eszipping code only

Author: andreespirela

crates/base/src/deno_runtime.rs

@@ -135,7 +135,8 @@ impl DenoRuntime {
 
         // TODO: check for other potential main paths (eg: index.js, index.tsx)
         let mut main_module_url = base_url.join("index.ts")?;
-        if maybe_entrypoint.is_some() {
+        let is_some_entry_point = maybe_entrypoint.is_some();
+        if is_some_entry_point {
             main_module_url = Url::parse(&maybe_entrypoint.unwrap())?;
         }
 
@@ -148,6 +149,8 @@ impl DenoRuntime {
         }
 
         let mut maybe_arc_import_map = None;
+        let only_module_code =
+            maybe_module_code.is_some() && maybe_eszip.is_none() && !is_some_entry_point;
 
         let eszip = if let Some(eszip_payload) = maybe_eszip {
             eszip_payload
@@ -170,8 +173,16 @@ impl DenoRuntime {
             let arc_emitter_factory = Arc::new(emitter_factory);
 
             let main_module_url_file_path = main_module_url.clone().to_file_path().unwrap();
+
+            let maybe_code = if only_module_code {
+                maybe_module_code
+            } else {
+                None
+            };
+
             let eszip =
-                generate_binary_eszip(main_module_url_file_path, arc_emitter_factory).await?;
+                generate_binary_eszip(main_module_url_file_path, arc_emitter_factory, maybe_code)
+                    .await?;
 
             EszipPayloadKind::Eszip(eszip)
         };
@@ -240,7 +251,7 @@ impl DenoRuntime {
             module_code,
         } = rt_provider;
 
-        let mod_code = module_code.or(maybe_module_code);
+        let mod_code = module_code;
 
         let extensions = vec![
             sb_core_permissions::init_ops(net_access_disabled),
@@ -426,7 +437,7 @@ impl DenoRuntime {
 #[cfg(test)]
 mod test {
     use crate::deno_runtime::DenoRuntime;
-    use deno_core::ModuleCode;
+    use deno_core::{FastString, ModuleCode};
     use sb_graph::emitter::EmitterFactory;
     use sb_graph::{generate_binary_eszip, EszipPayloadKind};
     use sb_workers::context::{
@@ -442,6 +453,26 @@ mod test {
     use tokio::net::UnixStream;
     use tokio::sync::mpsc;
 
+    #[tokio::test]
+    async fn test_module_code_no_eszip() {
+        let (worker_pool_tx, _) = mpsc::unbounded_channel::<UserWorkerMsgs>();
+        DenoRuntime::new(WorkerContextInitOpts {
+            service_path: PathBuf::from("./test_cases/"),
+            no_module_cache: false,
+            import_map_path: None,
+            env_vars: Default::default(),
+            events_rx: None,
+            maybe_eszip: None,
+            maybe_entrypoint: None,
+            maybe_module_code: Some(FastString::from(String::from(
+                "Deno.serve((req) => new Response('Hello World'));",
+            ))),
+            conf: { WorkerRuntimeOpts::MainWorker(MainWorkerRuntimeOpts { worker_pool_tx }) },
+        })
+        .await
+        .expect("It should not panic");
+    }
+
     #[tokio::test]
     #[allow(clippy::arc_with_non_send_sync)]
     async fn test_eszip_with_source_file() {
@@ -451,7 +482,7 @@ mod test {
             .unwrap();
         let path_buf = PathBuf::from("./test_cases/eszip-source-test.ts");
         let emitter_factory = Arc::new(EmitterFactory::new());
-        let bin_eszip = generate_binary_eszip(path_buf, emitter_factory.clone())
+        let bin_eszip = generate_binary_eszip(path_buf, emitter_factory.clone(), None)
             .await
             .unwrap();
         fs::remove_file("./test_cases/eszip-source-test.ts").unwrap();
@@ -500,7 +531,7 @@ mod test {
         let file = PathBuf::from("./test_cases/eszip-silly-test/index.ts");
         let service_path = PathBuf::from("./test_cases/eszip-silly-test");
         let emitter_factory = Arc::new(EmitterFactory::new());
-        let binary_eszip = generate_binary_eszip(file, emitter_factory.clone())
+        let binary_eszip = generate_binary_eszip(file, emitter_factory.clone(), None)
             .await
             .unwrap();
 

crates/cli/src/main.rs

@@ -135,6 +135,7 @@ fn main() -> Result<(), anyhow::Error> {
                 let eszip = generate_binary_eszip(
                     path.canonicalize().unwrap(),
                     Arc::new(EmitterFactory::new()),
+                    None,
                 )
                 .await?;
                 let bin = eszip.into_bytes();

crates/module_fetcher/src/file_fetcher.rs

@@ -61,7 +61,7 @@ pub struct File {
 /// Simple struct implementing in-process caching to prevent multiple
 /// fs reads/net fetches for same file.
 #[derive(Debug, Clone, Default)]
-struct FileCache(Arc<Mutex<HashMap<ModuleSpecifier, File>>>);
+pub struct FileCache(Arc<Mutex<HashMap<ModuleSpecifier, File>>>);
 
 impl FileCache {
     pub fn get(&self, specifier: &ModuleSpecifier) -> Option<File> {
@@ -166,7 +166,7 @@ pub struct FetchOptions {
 pub struct FileFetcher {
     auth_tokens: AuthTokens,
     allow_remote: bool,
-    cache: FileCache,
+    cache: Arc<FileCache>,
     cache_setting: CacheSetting,
     http_cache: Arc<dyn HttpCache>,
     http_client: Arc<HttpClient>,
@@ -181,11 +181,12 @@ impl FileFetcher {
         allow_remote: bool,
         http_client: Arc<HttpClient>,
         blob_store: Arc<BlobStore>,
+        file_cache: Arc<FileCache>,
     ) -> Self {
         Self {
             auth_tokens: AuthTokens::new(env::var("DENO_AUTH_TOKENS").ok()),
             allow_remote,
-            cache: Default::default(),
+            cache: file_cache,
             cache_setting,
             http_cache,
             http_client,

crates/sb_graph/emitter.rs

@@ -16,7 +16,7 @@ use module_fetcher::cache::{
     RealDenoCacheEnv,
 };
 use module_fetcher::emit::Emitter;
-use module_fetcher::file_fetcher::FileFetcher;
+use module_fetcher::file_fetcher::{FileCache, FileFetcher};
 use module_fetcher::http_util::HttpClient;
 use module_fetcher::permissions::Permissions;
 use sb_node::{NodeResolver, PackageJson};
@@ -89,6 +89,7 @@ pub struct EmitterFactory {
     file_fetcher_cache_strategy: Option<CacheSetting>,
     file_fetcher_allow_remote: bool,
     pub maybe_import_map: Option<Arc<ImportMap>>,
+    file_cache: Deferred<Arc<FileCache>>,
 }
 
 impl Default for EmitterFactory {
@@ -118,6 +119,7 @@ impl EmitterFactory {
             file_fetcher_cache_strategy: None,
             file_fetcher_allow_remote: true,
             maybe_import_map: None,
+            file_cache: Default::default(),
         }
     }
 
@@ -253,6 +255,10 @@ impl EmitterFactory {
         })
     }
 
+    pub fn file_cache(&self) -> &Arc<FileCache> {
+        self.file_cache.get_or_init(Default::default)
+    }
+
     pub fn get_lock_file_deferred(&self) -> &Option<Arc<Mutex<Lockfile>>> {
         self.lockfile.get_or_init(|| {
             if let Some(lockfile_data) = self.maybe_lockfile.clone() {
@@ -359,6 +365,7 @@ impl EmitterFactory {
             self.file_fetcher_allow_remote,
             http_client,
             blob_store,
+            self.file_cache().clone(),
         )
     }
 

crates/sb_graph/graph_util.rs

@@ -1,8 +1,9 @@
 use crate::emitter::EmitterFactory;
 use crate::graph_resolver::CliGraphResolver;
+use deno_ast::MediaType;
 use deno_core::error::{custom_error, AnyError};
 use deno_core::parking_lot::Mutex;
-use deno_core::ModuleSpecifier;
+use deno_core::{FastString, ModuleSpecifier};
 use deno_graph::ModuleError;
 use deno_graph::ResolutionError;
 use deno_semver::package::{PackageNv, PackageReq};
@@ -11,6 +12,7 @@ use eszip::deno_graph::{GraphKind, ModuleGraph, ModuleGraphError};
 use eszip::{deno_graph, EszipV2};
 use module_fetcher::args::lockfile::Lockfile;
 use module_fetcher::cache::ParsedSourceCache;
+use module_fetcher::file_fetcher::File;
 use sb_core::errors_rt::get_error_class_name;
 use sb_npm::CliNpmResolver;
 use std::path::PathBuf;
@@ -303,11 +305,33 @@ pub async fn create_eszip_from_graph_raw(
     eszip::EszipV2::from_graph(graph, &parser, Default::default())
 }
 
-pub async fn create_graph(file: PathBuf, emitter_factory: Arc<EmitterFactory>) -> ModuleGraph {
-    let binding = std::fs::canonicalize(&file).unwrap();
-    let specifier = binding.to_str().unwrap();
-    let format_specifier = format!("file:///{}", specifier);
-    let module_specifier = ModuleSpecifier::parse(&format_specifier).unwrap();
+pub async fn create_graph(
+    file: PathBuf,
+    emitter_factory: Arc<EmitterFactory>,
+    maybe_code: &Option<FastString>,
+) -> ModuleGraph {
+    let module_specifier = if let Some(code) = maybe_code {
+        let specifier = ModuleSpecifier::parse("file:///src/index.ts").unwrap();
+
+        emitter_factory.file_cache().insert(
+            specifier.clone(),
+            File {
+                maybe_types: None,
+                media_type: MediaType::TypeScript,
+                source: code.as_str().into(),
+                specifier: specifier.clone(),
+                maybe_headers: None,
+            },
+        );
+
+        specifier
+    } else {
+        let binding = std::fs::canonicalize(&file).unwrap();
+        let specifier = binding.to_str().unwrap();
+        let format_specifier = format!("file:///{}", specifier);
+
+        ModuleSpecifier::parse(&format_specifier).unwrap()
+    };
 
     let builder = ModuleGraphBuilder::new(emitter_factory, false);
 

crates/sb_graph/lib.rs

@@ -2,7 +2,7 @@ use crate::emitter::EmitterFactory;
 use crate::graph_util::{create_eszip_from_graph_raw, create_graph};
 use deno_ast::MediaType;
 use deno_core::error::AnyError;
-use deno_core::{serde_json, JsBuffer, ModuleSpecifier};
+use deno_core::{serde_json, FastString, JsBuffer, ModuleSpecifier};
 use deno_fs::{FileSystem, RealFs};
 use deno_npm::NpmSystemInfo;
 use eszip::EszipV2;
@@ -27,14 +27,19 @@ pub enum EszipPayloadKind {
 pub async fn generate_binary_eszip(
     file: PathBuf,
     emitter_factory: Arc<EmitterFactory>,
+    maybe_module_code: Option<FastString>,
 ) -> Result<EszipV2, AnyError> {
-    let graph = create_graph(file.clone(), emitter_factory.clone()).await;
+    let graph = create_graph(file.clone(), emitter_factory.clone(), &maybe_module_code).await;
     let eszip = create_eszip_from_graph_raw(graph, Some(emitter_factory.clone())).await;
 
     if let Ok(mut eszip) = eszip {
         let fs_path = file.clone();
-        let entry_content = RealFs.read_file_sync(fs_path.clone().as_path()).unwrap();
-        let source_code: Arc<str> = String::from_utf8(entry_content.clone())?.into();
+        let source_code: Arc<str> = if let Some(code) = maybe_module_code {
+            code.as_str().into()
+        } else {
+            let entry_content = RealFs.read_file_sync(fs_path.clone().as_path()).unwrap();
+            String::from_utf8(entry_content.clone())?.into()
+        };
         let emit_source = emitter_factory.emitter().unwrap().emit_parsed_source(
             &ModuleSpecifier::parse("http://localhost").unwrap(),
             MediaType::from_path(fs_path.clone().as_path()),