patch of feat(feed): implement feed service · round #0 · pull #8 · rocksky.app/rocksky

+35

crates/feed/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rocksky-feed"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       authors.workspace = true

     

       5
       5
       +
       edition.workspace = true

     

       6
       6
       +
       license.workspace = true

     

       7
       7
       +
       repository.workspace = true

     

       8
       8
       +
       

     

       9
       9
       +
       [dependencies]

     

       10
       10
       +
       warp = "0.3.7"

     

       11
       11
       +
       owo-colors = "4.1.0"

     

       12
       12
       +
       anyhow = "1.0.100"

     

       13
       13
       +
       atrium-api = "0.25.5"

     

       14
       14
       +
       atrium-xrpc-client = "0.5.14"

     

       15
       15
       +
       chrono = { version = "= 0.4.39", features = ["serde"] }

     

       16
       16
       +
       duckdb = { version = "1.2.0", features = ["chrono"] }

     

       17
       17
       +
       jetstream-oxide = "=0.1.2"

     

       18
       18
       +
       reqwest = { version = "0.12.12", features = [

     

       19
       19
       +
         "rustls-tls",

     

       20
       20
       +
         "json",

     

       21
       21
       +
         "multipart",

     

       22
       22
       +
       ], default-features = false }

     

       23
       23
       +
       serde = "1.0.227"

     

       24
       24
       +
       serde_json = "1.0.145"

     

       25
       25
       +
       tokio = { version = "1.43.0", features = ["full"] }

     

       26
       26
       +
       tracing = "0.1.41"

     

       27
       27
       +
       dotenv = "0.15.0"

     

       28
       28
       +
       sqlx = { version = "0.8.3", features = [

     

       29
       29
       +
         "runtime-tokio",

     

       30
       30
       +
         "tls-rustls",

     

       31
       31
       +
         "postgres",

     

       32
       32
       +
         "chrono",

     

       33
       33
       +
         "derive",

     

       34
       34
       +
         "macros",

     

       35
       35
       +
       ] }

+35

crates/feed/src/config.rs

···

       1
       1
       +
       use std::env;

     

       2
       2
       +
       

     

       3
       3
       +
       use dotenv::dotenv;

     

       4
       4
       +
       

     

       5
       5
       +
       #[derive(Debug, Clone)]

     

       6
       6
       +
       /// Configuration values for a Feed service

     

       7
       7
       +
       pub struct Config {

     

       8
       8
       +
           /// Your account's decentralized identifier (DID)

     

       9
       9
       +
           /// A DID is a persistent, long-term identifier for every account. Usually look like did:plc:ewvi7nxzyoun6zhxrhs64oiz.

     

       10
       10
       +
           pub publisher_did: String,

     

       11
       11
       +
           /// The host name for your feed generator.

     

       12
       12
       +
           ///

     

       13
       13
       +
           /// For example: if github were to host a feed generator service at their domain they would set this value to `github.com`

     

       14
       14
       +
           ///

     

       15
       15
       +
           /// You can develop your feed locally without setting this to a real value. However, when publishing, this value must be a domain that:

     

       16
       16
       +
           /// - Points to your service.

     

       17
       17
       +
           /// - Is secured with SSL (HTTPS).

     

       18
       18
       +
           /// - Is accessible on the public internet.

     

       19
       19
       +
           pub feed_generator_hostname: String,

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       impl Config {

     

       23
       23
       +
           /// Loads the config from a local .env file containing these variables

     

       24
       24
       +
           /// PUBLISHER_DID

     

       25
       25
       +
           /// FEED_GENERATOR_HOSTNAME

     

       26
       26
       +
           pub fn load_env_config() -> Self {

     

       27
       27
       +
               dotenv().expect("Missing .env");

     

       28
       28
       +
               Config {

     

       29
       29
       +
                   publisher_did: env::var("PUBLISHER_DID")

     

       30
       30
       +
                       .expect(".env file is missing an entry for PUBLISHER_DID"),

     

       31
       31
       +
                   feed_generator_hostname: env::var("FEED_GENERATOR_HOSTNAME")

     

       32
       32
       +
                       .expect(".env file is missing an entry for FEED_GENERATOR_HOSTNAME"),

     

       33
       33
       +
               }

     

       34
       34
       +
           }

     

       35
       35
       +
       }

+10

crates/feed/src/feed_handler.rs

···

       1
       1
       +
       use crate::types::{FeedResult, Request, Scrobble, Uri};

     

       2
       2
       +
       

     

       3
       3
       +
       /// A feed handler is responsible for

     

       4
       4
       +
       /// - Storing and managing firehose input.

     

       5
       5
       +
       /// - Serving responses to feed requests with `serve_feed`

     

       6
       6
       +
       pub trait FeedHandler {

     

       7
       7
       +
           fn insert_scrobble(&self, scrobble: Scrobble) -> impl std::future::Future<Output = ()> + Send;

     

       8
       8
       +
           fn delete_scrobble(&self, uri: Uri) -> impl std::future::Future<Output = ()> + Send;

     

       9
       9
       +
           fn serve_feed(&self, request: Request) -> impl std::future::Future<Output = FeedResult> + Send;

     

       10
       10
       +
       }

+54

crates/feed/src/types.rs

···

       1
       1
       +
       #[derive(Debug, Clone)]

     

       2
       2
       +
       pub struct Request {

     

       3
       3
       +
           pub cursor: Option<String>,

     

       4
       4
       +
           pub feed: String,

     

       5
       5
       +
           pub limit: Option<u8>,

     

       6
       6
       +
       }

     

       7
       7
       +
       

     

       8
       8
       +
       #[derive(Debug, Clone)]

     

       9
       9
       +
       pub struct Cid(pub String);

     

       10
       10
       +
       

     

       11
       11
       +
       #[derive(Debug, Clone)]

     

       12
       12
       +
       pub struct Did(pub String);

     

       13
       13
       +
       

     

       14
       14
       +
       #[derive(Debug, Clone, Hash, PartialEq, Eq)]

     

       15
       15
       +
       pub struct Uri(pub String);

     

       16
       16
       +
       

     

       17
       17
       +
       #[derive(Debug, Clone)]

     

       18
       18
       +
       pub struct FeedResult {

     

       19
       19
       +
           pub cursor: Option<String>,

     

       20
       20
       +
           pub feed: Vec<Uri>,

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       pub struct FeedSkeletonQuery {}

     

       24
       24
       +
       

     

       25
       25
       +
       #[derive(Deserialize)]

     

       26
       26
       +
       pub struct FeedSkeletonParameters {}

     

       27
       27
       +
       

     

       28
       28
       +
       impl Into<FeedSkeletonQuery> for FeedSkeletonParameters {

     

       29
       29
       +
           fn into(self) -> FeedSkeletonQuery {

     

       30
       30
       +
               FeedSkeletonQuery {}

     

       31
       31
       +
           }

     

       32
       32
       +
       }

     

       33
       33
       +
       

     

       34
       34
       +
       #[derive(Debug, Clone)]

     

       35
       35
       +
       pub struct Scrobble {}

     

       36
       36
       +
       

     

       37
       37
       +
       use serde::{Deserialize, Serialize};

     

       38
       38
       +
       

     

       39
       39
       +
       #[derive(Serialize)]

     

       40
       40
       +
       pub(crate) struct DidDocument {

     

       41
       41
       +
           #[serde(rename = "@context")]

     

       42
       42
       +
           pub(crate) context: Vec<String>,

     

       43
       43
       +
           pub(crate) id: String,

     

       44
       44
       +
           pub(crate) service: Vec<Service>,

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       47
       47
       +
       #[derive(Serialize)]

     

       48
       48
       +
       pub(crate) struct Service {

     

       49
       49
       +
           pub(crate) id: String,

     

       50
       50
       +
           #[serde(rename = "type")]

     

       51
       51
       +
           pub(crate) type_: String,

     

       52
       52
       +
           #[serde(rename = "serviceEndpoint")]

     

       53
       53
       +
           pub(crate) service_endpoint: String,

     

       54
       54
       +
       }

+1

crates/rockskyd/Cargo.toml

···

       20
       20
        
       rocksky-spotify = { path = "../spotify" }

     

       21
       21
        
       rocksky-tracklist = { path = "../tracklist" }

     

       22
       22
        
       rocksky-webscrobbler = { path = "../webscrobbler" }

     

       23
       23
       +
       rocksky-feed = { path = "../feed" }

     

       23
       24
        
       tracing = "0.1.41"

     

       24
       25
        
       tracing-subscriber = "0.3.20"

     

       25
       26
        
       tracing-log = "0.2.0"

+6

crates/rockskyd/src/cmd/feed.rs

···

       1
       1
       +
       use anyhow::Error;

     

       2
       2
       +
       

     

       3
       3
       +
       pub async fn serve() -> Result<(), Error> {

     

       4
       4
       +
           rocksky_feed::run().await;

     

       5
       5
       +
           Ok(())

     

       6
       6
       +
       }

+1

crates/rockskyd/src/cmd/mod.rs

···

       1
       1
        
       pub mod analytics;

     

       2
       2
        
       pub mod dropbox;

     

       3
       3
       +
       pub mod feed;

     

       3
       4
        
       pub mod googledrive;

     

       4
       5
        
       pub mod jetstream;

     

       5
       6
        
       pub mod playlist;

+9

crates/rockskyd/src/main.rs

···

       32
       32
        
               .subcommand(Command::new("spotify").about("Start Spotify Listener Service"))

     

       33
       33
        
               .subcommand(Command::new("tracklist").about("Start User Current Track Queue Service"))

     

       34
       34
        
               .subcommand(Command::new("webscrobbler").about("Start Webscrobbler API"))

     

       35
       35
       +
               .subcommand(

     

       36
       36
       +
                   Command::new("feed")

     

       37
       37
       +
                       .about("Feed related commands")

     

       38
       38
       +
                       .subcommand(Command::new("serve").about("Serve the Rocksky Feed API")),

     

       39
       39
       +
               )

     

       35
       40
        
       }

     

       36
       41
        
       

     

       37
       42
        
       #[tokio::main]

     
···

       85
       90
        
               Some(("webscrobbler", _)) => {

     

       86
       91
        
                   cmd::webscrobbler::start_webscrobbler_service().await?;

     

       87
       92
        
               }

     

       93
       93
       +
               Some(("feed", sub_m)) => match sub_m.subcommand() {

     

       94
       94
       +
                   Some(("serve", _)) => cmd::feed::serve().await?,

     

       95
       95
       +
                   _ => println!("Unknown feed command"),

     

       96
       96
       +
               },

     

       88
       97
        
               _ => {

     

       89
       98
        
                   println!("No valid subcommand was used. Use --help to see available commands.");

     

       90
       99
        
               }