http: Only count publicly seeded repositories — radicle-explorer

Previously the /api/v1/stats endpoint would count any repository that is in the storage regardless of whether the repository is publicly seeded or not.

👉 Preview 👉 Workflow runs 👉 Branch on GitHub

                   "closed": 0,
                 },
                 "id": RID,
                 "seeding": 0,
                 "seeding": 1,
               },
               {
                 "name": "again-hello-world",

                   "closed": 0,
                 },
                 "id": "rad:z4GypKmh1gkEfmkXtarcYnkvtFUfE",
                 "seeding": 0,
                 "seeding": 1,
               }
             ])
         );

                   "closed": 0,
                 },
                 "id": RID,
                 "seeding": 0,
                 "seeding": 1,
               },
               {
                 "name": "again-hello-world",

                   "closed": 0,
                 },
                 "id": "rad:z4GypKmh1gkEfmkXtarcYnkvtFUfE",
                 "seeding": 0,
                 "seeding": 1,
               }
             ])
         );

     use axum::extract::connect_info::MockConnectInfo;
     use axum::http::StatusCode;
     use pretty_assertions::assert_eq;
     use serde_json::json;
     use serde_json::{json, Value};
     use crate::test::*;

         let response = get(&app, format!("/nodes/{nid}/inventory")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(response.json().await, json!([]));
         let json_response = response.json().await;
         let mut arr = match json_response {
             Value::Array(arr) => arr,
             _ => panic!("Expected JSON array in response"),
         };
         arr.sort_by(|a, b| a.as_str().cmp(&b.as_str()));
         assert_eq!(
             arr,
             vec![
                 json!("rad:z4FucBZHZMCsxTyQE1dfE2YR59Qbp"),
                 json!("rad:z4GypKmh1gkEfmkXtarcYnkvtFUfE"),
             ]
         );
     }
 }

                     "alias": CONTRIBUTOR_ALIAS
                   }
                 ],
                 "seeds": 0,
                 "seeds": 1,
               },
               {
                 "rid": "rad:z4GypKmh1gkEfmkXtarcYnkvtFUfE",

 use axum::{Json, Router};
 use serde_json::json;
 use radicle::storage::ReadStorage;
 use radicle::node::routing::Store;
 use crate::api::error::Error;
 use crate::api::Context;

 /// Return the stats for the node.
 /// `GET /stats`
 async fn stats_handler(State(ctx): State<Context>) -> impl IntoResponse {
     let total = ctx.profile.storage.repositories()?.len();
     let db = &ctx.profile.database()?;
     let nid = ctx.profile.public_key;
     Ok::<_, Error>(Json(json!({ "repos": { "total": total } })))
     let total_seeded = db.get_inventory(&nid)?.len();
     Ok::<_, Error>(Json(json!({ "repos": { "total": total_seeded } })))
 }
 #[cfg(test)]

         let response = get(&app, "/stats").await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(response.json().await, json!({ "repos": { "total": 3 } }));
         assert_eq!(response.json().await, json!({ "repos": { "total": 2 } }));
     }
 }

 use axum::body::{Body, Bytes};
 use axum::http::{Method, Request};
 use axum::Router;
 use radicle::node::{Features, Timestamp, UserAgent};
 use serde_json::Value;
 use tower::ServiceExt;

 use radicle::identity::Visibility;
 use radicle::profile::{env, Home};
 use radicle::storage::ReadStorage;
 use radicle::Storage;
 use radicle::{node, profile};
 use radicle::{Node, Storage};
 use radicle_crypto::test::signer::MockSigner;
 use crate::api::Context;

     let mut db = home.policies_mut().unwrap();
     db.follow(&keypair.pk.into(), Some(&alias)).unwrap();
     let node_db = home.database_mut().unwrap();
     node_db
         .init(
             &keypair.pk.into(),
             Features::SEED,
             &alias,
             &UserAgent::default(),
             Timestamp::try_from(TIMESTAMP).unwrap(),
             [],
         )
         .unwrap();
     radicle::storage::git::transport::local::register(storage.clone());
     keystore.store(keypair.clone(), "radicle", None).unwrap();

     )
     .unwrap();
     policies.seed(&rid, node::policy::Scope::All).unwrap();
     let node_handle = &mut Node::new(profile.socket());
     profile
         .seed(rid, node::policy::Scope::All, node_handle)
         .unwrap();
     profile.add_inventory(rid, node_handle).unwrap();
     let storage = &profile.storage;
     let repo = storage.repository(rid).unwrap();

     )
     .unwrap();
     policies.seed(&rid, node::policy::Scope::Followed).unwrap();
     profile
         .seed(rid, node::policy::Scope::Followed, node_handle)
         .unwrap();
     profile.add_inventory(rid, node_handle).unwrap();
     let options = crate::Options {
         aliases: std::collections::HashMap::new(),