cache fill server function

crates/weaver-server/src/components/entry.rs

···
 #![allow(non_snake_case)]
 
-use crate::fetch;
-use dioxus::prelude::*;
-use jacquard::{smol_str::SmolStr, types::string::AtIdentifier, CowStr};
+#[allow(unused_imports)]
+use crate::{blobcache::BlobCache, fetch};
+#[allow(unused_imports)]
+use dioxus::{fullstack::extract::Extension, CapturedError};
+use dioxus::{
+    fullstack::{get_server_url, reqwest},
+    prelude::*,
+};
+use jacquard::smol_str::ToSmolStr;
+#[allow(unused_imports)]
+use jacquard::{
+    smol_str::SmolStr,
+    types::{cid::Cid, string::AtIdentifier},
+};
+#[allow(unused_imports)]
+use std::sync::Arc;
 use weaver_api::sh_weaver::notebook::{entry, BookEntryView};
 
 #[component]
 pub fn Entry(ident: AtIdentifier<'static>, book_title: SmolStr, title: SmolStr) -> Element {
     let entry = use_resource(use_reactive!(|(ident, book_title, title)| async move {
         let fetcher = use_context::<fetch::CachedFetcher>();
-        fetcher
-            .get_entry(ident, book_title, title)
+        let entry = fetcher
+            .get_entry(ident.clone(), book_title, title)
             .await
             .ok()
-            .flatten()
+            .flatten();
+        if let Some(entry) = &entry {
+            let entry = &entry.1;
+            if let Some(embeds) = &entry.embeds {
+                if let Some(images) = &embeds.images {
+                    for image in &images.images {
+                        let cid = image.image.blob().cid();
+                        cache_blob(
+                            ident.to_smolstr(),
+                            cid.to_smolstr(),
+                            image.name.as_ref().map(|n| n.to_smolstr()),
+                        )
+                        .await
+                        .ok();
+                    }
+                }
+            }
+        }
+        entry
     }));
 
     rsx! {
···
         }
     }
 }
+
+#[put("/cache/{ident}/{cid}?name", cache: Extension<Arc<BlobCache>>)]
+pub async fn cache_blob(ident: SmolStr, cid: SmolStr, name: Option<SmolStr>) -> Result<()> {
+    let ident = AtIdentifier::new_owned(ident)?;
+    let cid = Cid::new_owned(cid.as_bytes())?;
+    cache.cache(ident, cid, name).await
+}

crates/weaver-server/src/fetch.rs

···
-use dioxus::{CapturedError, Result};
+use dioxus::Result;
 use jacquard::{client::BasicClient, smol_str::SmolStr, types::ident::AtIdentifier};
 use std::{
     sync::{Arc, Mutex},
···
     com_atproto::repo::strong_ref::StrongRef,
     sh_weaver::notebook::{entry::Entry, BookEntryView, NotebookView},
 };
-use weaver_common::view::{entry_by_title, fetch_entry_view, notebook_by_title, view_entry};
+use weaver_common::view::{entry_by_title, notebook_by_title};
 
 #[derive(Clone)]
 pub struct CachedFetcher {

crates/weaver-server/src/main.rs

···
 // need dioxus
 use components::{Entry, Repository, RepositoryIndex};
 use dioxus::{fullstack::FullstackContext, prelude::*};
-use jacquard::{
-    client::BasicClient, smol_str::SmolStr, types::did::Did, types::string::AtIdentifier, CowStr,
-};
+use jacquard::{client::BasicClient, smol_str::SmolStr, types::string::AtIdentifier};
 use std::sync::Arc;
 use views::{Home, Navbar, Notebook, NotebookIndex, NotebookPage};
 
···
         Home {},
         #[layout(ErrorLayout)]
         #[nest("/:ident")]
-          #[layout(components::Repository)]
+          #[layout(Repository)]
             #[route("/")]
             RepositoryIndex { ident: AtIdentifier<'static> },
             #[nest("/:book_title")]
-              #[layout(views::Notebook)]
+              #[layout(Notebook)]
               #[route("/")]
               NotebookIndex { ident: AtIdentifier<'static>, book_title: SmolStr },
                 #[route("/:title")]
···
             |mut req: Request, next: Next| async move {
                 // Attach some extra state to the request
 
+                use crate::blobcache::BlobCache;
                 use crate::fetch::CachedFetcher;
                 use std::convert::Infallible;
                 use std::sync::Arc;
···
                     .insert(Arc::new(CachedFetcher::new(Arc::new(
                         BasicClient::unauthenticated(),
                     ))));
+                req.extensions_mut()
+                    .insert(Arc::new(BlobCache::new(Arc::new(
+                        BasicClient::unauthenticated(),
+                    ))));
 
                 // And then return the response with `next.run()
                 Ok::<_, Infallible>(next.run(req).await)
···
         }
     }
 }
-
-struct Config {
-    did: Option<Did<'static>>,
-}