fix: duplicate read proto

Cargo.toml

@@ -146,6 +146,7 @@ convert_case = "0.6.0"
 rand = "0.8.5"
 tailcall-macros = { path = "tailcall-macros" }
 tonic-types = "0.11.0"
+async-lock = "3.3.0"
 
 
 [dev-dependencies]

src/config/reader.rs

@@ -1,6 +1,9 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
 use std::path::Path;
 use std::sync::Arc;
 
+use async_lock::Mutex;
 use rustls_pemfile;
 use rustls_pki_types::{
     CertificateDer, PrivateKeyDer, PrivatePkcs1KeyDer, PrivatePkcs8KeyDer, PrivateSec1KeyDer,
@@ -24,10 +27,11 @@ pub struct ConfigReader {
 
 impl ConfigReader {
     pub fn init(runtime: TargetRuntime) -> Self {
+        let cache: Arc<Mutex<RefCell<HashMap<String, String>>>> = Default::default();
         Self {
             runtime: runtime.clone(),
-            resource_reader: ResourceReader::init(runtime.clone()),
-            proto_reader: ProtoReader::init(runtime),
+            resource_reader: ResourceReader::init(runtime.clone(), cache.clone()),
+            proto_reader: ProtoReader::init(runtime, cache.clone()),
         }
     }
 

src/generator/generator.rs

@@ -12,7 +12,7 @@ pub struct Generator {
 }
 impl Generator {
     pub fn init(runtime: TargetRuntime) -> Self {
-        Self { proto_reader: ProtoReader::init(runtime) }
+        Self { proto_reader: ProtoReader::init(runtime, Default::default()) }
     }
 
     pub async fn read_all<T: AsRef<str>>(

src/proto_reader.rs

@@ -1,6 +1,9 @@
+use std::cell::RefCell;
 use std::collections::{HashMap, VecDeque};
+use std::sync::Arc;
 
 use anyhow::Context;
+use async_lock::Mutex;
 use futures_util::future::join_all;
 use prost_reflect::prost_types::{FileDescriptorProto, FileDescriptorSet};
 use protox::file::{FileResolver, GoogleFileResolver};
@@ -18,8 +21,11 @@ pub struct ProtoMetadata {
 }
 
 impl ProtoReader {
-    pub fn init(runtime: TargetRuntime) -> Self {
-        Self { resource_reader: ResourceReader::init(runtime) }
+    pub fn init(
+        runtime: TargetRuntime,
+        cache: Arc<Mutex<RefCell<HashMap<String, String>>>>,
+    ) -> Self {
+        Self { resource_reader: ResourceReader::init(runtime, cache) }
     }
 
     pub async fn read_all<T: AsRef<str>>(&self, paths: &[T]) -> anyhow::Result<Vec<ProtoMetadata>> {
@@ -104,7 +110,7 @@ mod test_proto_config {
     #[tokio::test]
     async fn test_resolve() {
         // Skipping IO tests as they are covered in reader.rs
-        let reader = ProtoReader::init(crate::runtime::test::init(None));
+        let reader = ProtoReader::init(crate::runtime::test::init(None), Default::default());
         reader
             .read_proto("google/protobuf/empty.proto")
             .await
@@ -133,7 +139,7 @@ mod test_proto_config {
         let runtime = crate::runtime::test::init(None);
         let file_rt = runtime.file.clone();
 
-        let reader = ProtoReader::init(runtime);
+        let reader = ProtoReader::init(runtime, Default::default());
         let helper_map = reader
             .resolve_descriptors(reader.read_proto(&test_file).await?)
             .await?;
@@ -177,7 +183,7 @@ mod test_proto_config {
     #[tokio::test]
     async fn test_proto_no_pkg() -> Result<()> {
         let runtime = crate::runtime::test::init(None);
-        let reader = ProtoReader::init(runtime);
+        let reader = ProtoReader::init(runtime, Default::default());
         let mut proto_no_pkg = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
         proto_no_pkg.push("src/grpc/tests/proto_no_pkg.graphql");
         let config_module = reader.read(proto_no_pkg.to_str().unwrap()).await;

src/resource_reader.rs

@@ -1,3 +1,8 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use async_lock::Mutex;
 use futures_util::future::join_all;
 use futures_util::TryFutureExt;
 use url::Url;
@@ -13,14 +18,44 @@
 
 pub struct ResourceReader {
     runtime: TargetRuntime,
+    // Cache file content, path->content
+    cache: Arc<Mutex<RefCell<HashMap<String, String>>>>,
 }
 
 impl ResourceReader {
-    pub fn init(runtime: TargetRuntime) -> Self {
-        Self { runtime }
+    pub fn init(
+        runtime: TargetRuntime,
+        cache: Arc<Mutex<RefCell<HashMap<String, String>>>>,
+    ) -> Self {
+        Self { runtime, cache }
     }
     /// Reads a file from the filesystem or from an HTTP URL
     pub async fn read_file<T: ToString>(&self, file: T) -> anyhow::Result<FileRead> {
+        // check cache
+        let file_path = file.to_string();
+        let content = self
+            .cache
+            .lock()
+            .await
+            .get_mut()
+            .get(&file_path)
+            .map(|v| v.to_owned());
+        let content = if let Some(content) = content {
+            content
+        } else {
+            let content = self.do_read_file(file.to_string()).await?;
+            self.cache
+                .lock()
+                .await
+                .get_mut()
+                .insert(file_path.to_owned(), content.clone());
+            content
+        };
+
+        Ok(FileRead { content, path: file_path })
+    }
+
+    async fn do_read_file<T: ToString>(&self, file: T) -> anyhow::Result<String> {
         // Is an HTTP URL
         let content = if let Ok(url) = Url::parse(&file.to_string()) {
             if url.scheme().starts_with("http") {
@@ -41,8 +76,7 @@
 
             self.runtime.file.read(&file.to_string()).await?
         };
-
-        Ok(FileRead { content, path: file.to_string() })
+        Ok(content)
     }
 
     /// Reads all the files in parallel