feat: browse feeds

Author: ymgyt

.helix/languages.toml

@@ -24,4 +24,4 @@ lens.enable = false
 hover.actions.enable = false
 
 [language-server.rust-analyzer.config.cargo]
-features = []
+features = ["auth_static_fut", "introspection"]

Cargo.lock

@@ -1,5 +1,6 @@
 set shell := ["nu", "-c"]
 kvsd_user := "synduser"
+github_pat := env_var_or_default("GH_PAT", "")
 
 # List recipe
 default:
@@ -16,9 +17,10 @@ fmt: fmt-toml
 fmt-toml:
   taplo fmt **.toml
 
+
 update-gql-schema:
-  graphql-client introspect-schema http://localhost:5959/graphql \
-    --header 'authorization: me' out> syndterm/gql/schema.json
+  @graphql-client introspect-schema http://localhost:5959/graphql \
+    --header 'authorization: github {{github_pat}}' out> syndterm/gql/schema.json
 
 
 gen-gql:
@@ -48,7 +50,7 @@ kvsd:
 
 # Run api
 api:
-  cd syndapi; RUST_LOG="syndapi=info,synd::feed::cache=debug,info" cargo run -- \
+  cd syndapi; RUST_LOG="syndapi=info,synd::feed::cache=debug,info" cargo run --features "introspection" -- \
     --kvsd-host 127.0.0.1 --kvsd-port 7379 --kvsd-username {{kvsd_user}} --kvsd-password secret
 
 # Run term

justfile

@@ -52,6 +52,10 @@ impl Entry {
         self.0.summary.as_ref().map(|text| text.content.as_str())
     }
 
+    pub fn website_url(&self, feed_type: FeedType) -> Option<&str> {
+        link::find_website_url(feed_type, &self.0.links)
+    }
+
     /// Return approximate entry bytes size
     pub fn approximate_size(&self) -> usize {
         let content_size = self
@@ -119,6 +123,18 @@ impl FeedMeta {
     }
 }
 
+impl<'a> From<&'a FeedMeta> for Cow<'a, FeedMeta> {
+    fn from(value: &'a FeedMeta) -> Self {
+        Cow::Borrowed(value)
+    }
+}
+
+impl From<FeedMeta> for Cow<'static, FeedMeta> {
+    fn from(value: FeedMeta) -> Self {
+        Cow::Owned(value)
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct Feed {
     meta: FeedMeta,
@@ -146,7 +162,7 @@ impl Feed {
 
 impl From<(FeedUrl, feed_rs::model::Feed)> for Feed {
     fn from((url, mut feed): (FeedUrl, feedrs::Feed)) -> Self {
-        let entries = std::mem::replace(&mut feed.entries, Vec::new());
+        let entries = std::mem::take(&mut feed.entries);
         let entries = entries.into_iter().map(Entry).collect();
 
         let meta = FeedMeta { url, feed };

synd/src/types.rs

@@ -19,25 +19,31 @@ feed-rs = { workspace = true }
 futures-util = { workspace = true }
 graphql_client = { workspace = true }
 kvsd = { version = "0.1.2" }
-moka = { workspace = true, features = ["future"]}
+moka = { workspace = true, features = ["future"] }
 reqwest = { workspace = true }
 serde = { workspace = true }
 serde_json = "1.0.111"
-supports-color = { version = "2.1.0"}
+supports-color = { version = "2.1.0" }
 synd = { path = "../synd" }
 thiserror = "1.0.56"
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 tower = { version = "0.4.13", default_features = false, features = [
-"limit","timeout"
+  "limit",
+  "timeout",
 
 ] }
 tower-http = { version = "0.5.1", default_features = false, features = [
-  "trace","sensitive-headers","cors","limit"
+  "trace",
+  "sensitive-headers",
+  "cors",
+  "limit",
 ] }
+pin-project = "1.1.4"
 
-# handson
 [features]
 
-foo = []
+# Enable graphql introspection
+introspection = []
+auth_static_fut = []

syndapi/Cargo.toml

@@ -2,7 +2,7 @@ mod query;
 pub use query::Query;
 
 mod mutation;
-use async_graphql::{EmptySubscription, Schema};
+use async_graphql::{extensions::Tracing, EmptySubscription, Schema, SchemaBuilder};
 pub use mutation::Mutation;
 
 use crate::{principal::Principal, usecase};
@@ -37,6 +37,15 @@ pub mod handler {
     }
 }
 
+pub fn schema_builder() -> SchemaBuilder<Query, Mutation, EmptySubscription> {
+    #[cfg(feature = "introspection")]
+    let schema = Schema::build(Query, Mutation, EmptySubscription);
+    #[cfg(not(feature = "introspection"))]
+    let schema = Schema::build(Query, Mutation, EmptySubscription).disable_introspection();
+
+    schema.extension(Tracing)
+}
+
 impl<'a> usecase::Context for &async_graphql::Context<'a> {
     fn principal(&self) -> Principal {
         self.data_unchecked::<Principal>().clone()

syndapi/src/gql/mod.rs

@@ -1,7 +1,7 @@
 use std::{borrow::Cow, sync::Arc};
 
 use async_graphql::{
-    connection::{Connection, Edge},
+    connection::{Connection, ConnectionNameType, Edge, EdgeNameType, EmptyFields},
     Enum, Object, SimpleObject, ID,
 };
 use feed_rs::model as feedrs;
@@ -34,29 +34,44 @@ impl From<feedrs::Link> for Link {
     }
 }
 
-pub struct Entry(types::Entry);
+pub struct Entry<'a> {
+    meta: Cow<'a, types::FeedMeta>,
+    entry: types::Entry,
+}
 
 #[Object]
-impl Entry {
+impl<'a> Entry<'a> {
+    /// Feed of this entry
+    async fn feed(&'a self) -> FeedMeta<'a> {
+        self.meta.as_ref().into()
+    }
     /// Entry title
     async fn title(&self) -> Option<&str> {
-        self.0.title()
+        self.entry.title()
     }
 
     /// The time at which the entry published
     async fn published(&self) -> Option<scalar::Rfc3339Time> {
-        self.0.published().map(Into::into)
+        self.entry.published().map(Into::into)
     }
 
     /// Entry summary
     async fn summary(&self) -> Option<&str> {
-        self.0.summary()
+        self.entry.summary()
+    }
+
+    /// Link to websiteurl at which this entry is published
+    async fn website_url(&self) -> Option<&str> {
+        self.entry.website_url(self.meta.r#type())
     }
 }
 
-impl From<types::Entry> for Entry {
-    fn from(value: types::Entry) -> Self {
-        Self(value)
+impl<'a> Entry<'a> {
+    pub fn new(meta: impl Into<Cow<'a, types::FeedMeta>>, entry: types::Entry) -> Self {
+        Self {
+            meta: meta.into(),
+            entry,
+        }
     }
 }
 
@@ -103,12 +118,20 @@ impl Feed {
     async fn entries(
         &self,
         #[graphql(default = 5)] first: Option<i32>,
-    ) -> Connection<usize, Entry> {
+    ) -> Connection<
+        usize,
+        Entry,
+        EmptyFields,
+        EmptyFields,
+        FeedEntryConnectionName,
+        FeedEntryEdgeName,
+    > {
         let first = first.unwrap_or(5).max(0) as usize;
+        let meta = self.0.meta();
         let entries = self
             .0
             .entries()
-            .map(|entry| Entry(entry.clone()))
+            .map(|entry| Entry::new(meta, entry.clone()))
             .take(first)
             .collect::<Vec<_>>();
 
@@ -161,6 +184,22 @@ impl Feed {
     }
 }
 
+pub struct FeedEntryConnectionName;
+
+impl ConnectionNameType for FeedEntryConnectionName {
+    fn type_name<T: async_graphql::OutputType>() -> String {
+        "FeedEntryConnection".into()
+    }
+}
+
+pub struct FeedEntryEdgeName;
+
+impl EdgeNameType for FeedEntryEdgeName {
+    fn type_name<T: async_graphql::OutputType>() -> String {
+        "FeedEntryEdge".into()
+    }
+}
+
 impl From<Arc<types::Feed>> for Feed {
     fn from(value: Arc<types::Feed>) -> Self {
         Self(value)
@@ -182,19 +221,8 @@ impl From<types::FeedMeta> for FeedMeta<'static> {
     }
 }
 
-/// Entry with feed metadata
-pub(super) struct FeedEntry<'a> {
-    pub feed: FeedMeta<'a>,
-    pub entry: Entry,
-}
-
-#[Object]
-impl<'a> FeedEntry<'a> {
-    async fn feed(&self) -> &FeedMeta<'a> {
-        &self.feed
-    }
-
-    async fn entry(&self) -> &Entry {
-        &self.entry
+impl<'a> From<&'a types::FeedMeta> for FeedMeta<'a> {
+    fn from(value: &'a types::FeedMeta) -> Self {
+        Self(Cow::Borrowed(value))
     }
 }

syndapi/src/gql/object/mod.rs

@@ -5,7 +5,7 @@ use async_graphql::{
 
 use crate::{
     gql::{
-        object::{self, id, FeedEntry},
+        object::{self, id, Entry},
         run_usecase,
     },
     usecase::{
@@ -18,6 +18,7 @@ struct Subscription;
 
 #[Object]
 impl Subscription {
+    /// Return Subscribed feeds
     async fn feeds(
         &self,
         cx: &Context<'_>,
@@ -39,6 +40,7 @@ impl Subscription {
 
         let edges = feeds
             .into_iter()
+            .take(first)
             .map(|feed| (feed.meta().url().to_owned(), feed))
             .map(|(cursor, feed)| (cursor, object::Feed::from(feed)))
             .map(|(cursor, feed)| Edge::new(cursor, feed));
@@ -47,19 +49,14 @@ impl Subscription {
 
         Ok(connection)
     }
-}
-
-struct Feeds;
 
-#[Object]
-impl Feeds {
-    /// Return Latest Feed entries
+    /// Return subscribed latest entries order by published time.
     async fn entries<'cx>(
         &self,
         cx: &Context<'_>,
         after: Option<String>,
         #[graphql(default = 20)] first: Option<i32>,
-    ) -> Result<Connection<id::EntryId, FeedEntry<'cx>>> {
+    ) -> Result<Connection<id::EntryId, Entry<'cx>>> {
         let first = first.unwrap_or(20).min(200) as usize;
         let has_prev = after.is_some();
         let input = FetchEntriesInput {
@@ -73,19 +70,18 @@ impl Feeds {
         let has_next = entries.len() > first;
         let mut connection = Connection::new(has_prev, has_next);
 
-        let edges = entries.into_iter().map(move |(entry, feed_url)| {
-            let meta = feeds
-                .get(&feed_url)
-                .expect("FeedMeta not found. this is a bug")
-                .clone();
-            let cursor = entry.id().into();
-            let node = FeedEntry {
-                feed: meta.into(),
-                entry: entry.into(),
-            };
-
-            Edge::new(cursor, node)
-        });
+        let edges = entries
+            .into_iter()
+            .take(first)
+            .map(move |(entry, feed_url)| {
+                let meta = feeds
+                    .get(&feed_url)
+                    .expect("FeedMeta not found. this is a bug")
+                    .clone();
+                let cursor = entry.id().into();
+                let node = Entry::new(meta, entry);
+                Edge::new(cursor, node)
+            });
 
         connection.edges.extend(edges);
 
@@ -100,8 +96,4 @@ impl Query {
     async fn subscription(&self) -> Subscription {
         Subscription {}
     }
-
-    async fn feeds(&self) -> Feeds {
-        Feeds {}
-    }
 }

syndapi/src/gql/query.rs

@@ -10,8 +10,3 @@ pub mod principal;
 pub mod serve;
 pub mod service;
 pub mod usecase;
-
-#[cfg(feature = "foo")]
-mod hello {
-    pub fn hello() {}
-}