try this

Author: dsherret

cli/cache/module_info.rs

@@ -68,7 +68,16 @@ impl From<ModuleInfoCacheSourceHash> for String {
 /// deno_graph.
 pub struct ModuleInfoCache {
   conn: CacheDB,
-  pending_inserts: Mutex<Vec<(String, &'static str, String, String)>>,
+  sender: Mutex<
+    Option<
+      tokio::sync::mpsc::UnboundedSender<(
+        String,
+        &'static str,
+        String,
+        String,
+      )>,
+    >,
+  >,
 }
 
 impl ModuleInfoCache {
@@ -80,7 +89,7 @@ impl ModuleInfoCache {
   pub fn new(conn: CacheDB) -> Self {
     Self {
       conn,
-      pending_inserts: Mutex::new(Vec::new()),
+      sender: Default::default(),
     }
   }
 
@@ -89,7 +98,7 @@ impl ModuleInfoCache {
   pub(crate) fn recreate_with_version(self, version: &'static str) -> Self {
     Self {
       conn: self.conn.recreate_with_version(version),
-      pending_inserts: Mutex::new(Vec::new()),
+      sender: Default::default(),
     }
   }
 
@@ -140,50 +149,47 @@ impl ModuleInfoCache {
     source_hash: &ModuleInfoCacheSourceHash,
     module_info: &ModuleInfo,
   ) -> Result<(), AnyError> {
-    self.pending_inserts.lock().push((
+    let data = (
       specifier.to_string(),
       serialize_media_type(media_type),
       source_hash.as_str().to_string(),
       serde_json::to_string(&module_info).unwrap(),
-    ));
-    Ok(())
-  }
-
-  pub fn flush_pending_inserts(&self) {
-    let pending_inserts = {
-      let mut items = self.pending_inserts.lock();
-      let items = &mut *items;
-      std::mem::take(items)
-    };
+    );
 
-    if pending_inserts.is_empty() {
-      return;
+    let mut sender = self.sender.lock();
+    if let Some(sender) = &mut *sender {
+      let _ = sender.send(data);
+    } else {
+      let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
+      let conn = self.conn.clone();
+      let _ = deno_core::unsync::spawn(async move {
+        while let Some((specifier, media_type, source_hash, module_info)) =
+          rx.recv().await
+        {
+          let conn = conn.clone();
+          deno_core::unsync::spawn_blocking(move || {
+            let sql = "
+            INSERT OR REPLACE INTO
+              moduleinfocache (specifier, media_type, source_hash, module_info)
+            VALUES
+              (?1, ?2, ?3, ?4)";
+            let result = conn.execute(
+              sql,
+              params![specifier, media_type, source_hash, module_info],
+            );
+            if let Err(err) = result {
+              log::debug!("Error saving module cache info. {:#}", err);
+            }
+          })
+          .await
+          .unwrap();
+        }
+      });
+      tx.send(data).unwrap();
+      *sender = Some(tx);
     }
 
-    let conn = self.conn.clone();
-    let _ignore = deno_core::unsync::spawn_blocking(move || {
-      let sql = "
-        INSERT OR REPLACE INTO
-          moduleinfocache (specifier, media_type, source_hash, module_info)
-        VALUES
-          (?1, ?2, ?3, ?4)";
-      let result = conn.execute_bulk(
-        sql,
-        pending_inserts.iter(),
-        |(specifier, media_type, source_hash, module_info)| {
-          use deno_runtime::deno_webstorage::rusqlite::ToSql;
-          [
-            specifier as &dyn ToSql,
-            media_type as &dyn ToSql,
-            source_hash as &dyn ToSql,
-            module_info as &dyn ToSql,
-          ]
-        },
-      );
-      if let Err(err) = result {
-        log::debug!("Error saving module cache info. {:#}", err);
-      }
-    });
+    Ok(())
   }
 
   pub fn as_module_analyzer<'a>(

cli/graph_util.rs

@@ -442,7 +442,7 @@ impl ModuleGraphBuilder {
       .map(|r| r.as_reporter());
     let workspace_members =
       self.options.resolve_deno_graph_workspace_members()?;
-    let result = self
+    self
       .build_graph_with_npm_resolution_and_build_options(
         graph,
         options.roots,
@@ -461,9 +461,7 @@ impl ModuleGraphBuilder {
           resolver: Some(graph_resolver),
         },
       )
-      .await;
-    self.module_info_cache.flush_pending_inserts(); // flush regardless of sucess
-    result
+      .await
   }
 
   async fn build_graph_with_npm_resolution_and_build_options<'a>(