add repo and basic parsing

Cargo.toml

@@ -24,6 +24,7 @@ edition = { workspace = true }
 
 [dependencies]
 blend-config = { path = "./crates/blend-config" }
+blend-context = { path = "./crates/blend-context" }
 blend-db = { path = "./crates/blend-db" }
 blend-web = { path = "./crates/blend-web" }
 clap = { version = "4", features = ["derive"] }

crates/blend-context/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "blend-context"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+blend-config = { path = "../blend-config" }
+thiserror = { workspace = true }
+sqlx = { workspace = true, features = ["sqlite"] }

crates/blend-db/Cargo.toml

@@ -5,6 +5,7 @@ edition.workspace = true
 
 [dependencies]
 blend-config = { path = "../blend-config" }
+blend-context = { path = "../blend-context" }
 chrono = { workspace = true, features = ["serde"] }
 futures = "0"
 serde = { workspace = true, features = ["derive"] }

crates/blend-db/migrations/20240422224146_feeds.sql → crates/blend-db/migrations/20240422000000_feeds.sql

@@ -2,6 +2,6 @@ CREATE TABLE IF NOT EXISTS feeds (
   id INTEGER PRIMARY KEY NOT NULL,
   title TEXT,
   url TEXT,
-  published_at TEXT,
-  updated_at TEXT
+  published_at DATETIME,
+  updated_at DATETIME
 );

crates/blend-db/src/lib.rs

@@ -1,3 +1,4 @@
 pub mod client;
 pub mod error;
 pub mod model;
+pub mod repo;

crates/blend-db/src/model/feed.rs

@@ -1,16 +1,15 @@
+use chrono::NaiveDateTime;
 use serde::{Deserialize, Serialize};
+use sqlx::prelude::FromRow;
 use ts_rs::TS;
 
 #[derive(TS)]
 #[ts(export, export_to = "../../../ui/src/types/bindings/feed.ts")]
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, FromRow)]
 pub struct Feed {
     pub id: i64,
     pub url: Option<String>,
     pub title: Option<String>,
-    pub published_at: Option<String>,
-    pub updated_at: Option<String>,
-    // published_at: Option<chrono::DateTime<chrono::Utc>>,
-    // updated_at: Option<chrono::DateTime<chrono::Utc>>,
-    // entries: Vec<Entry>,
+    pub published_at: Option<NaiveDateTime>,
+    pub updated_at: Option<NaiveDateTime>,
 }

crates/blend-db/src/repo/feed.rs

@@ -0,0 +1,46 @@
+use crate::{error::DbResult, model};
+use chrono::{DateTime, Utc};
+
+pub struct FeedRepo {
+    ctx: blend_context::Context,
+}
+
+pub struct CreateFeedParams {
+    pub title: Option<String>,
+    pub url: Option<String>,
+    pub published_at: Option<DateTime<Utc>>,
+    pub updated_at: Option<DateTime<Utc>>,
+}
+
+impl FeedRepo {
+    pub fn new(ctx: blend_context::Context) -> Self {
+        Self { ctx }
+    }
+
+    pub async fn get_feeds(&self) -> DbResult<Vec<model::Feed>> {
+        sqlx::query_as!(model::Feed, "SELECT * FROM feeds")
+            .fetch_all(&self.ctx.db)
+            .await
+            .map_err(|err| err.into())
+    }
+
+    pub async fn create_feed(&self, data: CreateFeedParams) -> DbResult<i64> {
+        let mut conn = self.ctx.db.acquire().await?;
+
+        let id: i64 = sqlx::query!(
+            r#"
+                INSERT INTO feeds ( title, url, published_at, updated_at )
+                VALUES ( ?1, ?2, ?3, ?4 )
+                "#,
+            data.title,
+            data.url,
+            data.published_at,
+            data.updated_at,
+        )
+        .execute(&mut *conn)
+        .await?
+        .last_insert_rowid();
+
+        Ok(id)
+    }
+}

crates/blend-db/src/repo/mod.rs

@@ -0,0 +1 @@
+pub mod feed;

crates/blend-web/Cargo.toml

@@ -5,6 +5,7 @@ edition.workspace = true
 
 [dependencies]
 blend-config = { path = "../blend-config" }
+blend-context = { path = "../blend-context" }
 blend-crypto = { path = "../blend-crypto" }
 blend-parse = { path = "../blend-parse" }
 blend-db = { path = "../blend-db" }

crates/blend-web/src/error.rs

@@ -38,6 +38,9 @@ pub enum WebError {
     #[error(transparent)]
     CryptoError(#[from] blend_crypto::error::CryptoError),
 
+    #[error(transparent)]
+    DbError(#[from] blend_db::error::DbError),
+
     #[error(transparent)]
     ParseError(#[from] blend_parse::error::ParseError),
 }

crates/blend-web/src/lib.rs

@@ -1,18 +1,16 @@
 use self::error::WebResult;
 use axum::http::{header, HeaderValue, Method};
-use context::Context;
 use tokio::net::TcpListener;
 use tower_cookies::CookieManagerLayer;
 use tower_http::{cors, trace::TraceLayer};
 
-pub mod context;
 pub mod error;
 mod middleware;
 mod response;
 mod router;
 mod util;
 
-pub async fn serve(ctx: Context) -> WebResult<()> {
+pub async fn serve(ctx: blend_context::Context) -> WebResult<()> {
     tracing::info!(
         "Starting web server on {}:{}",
         ctx.blend.config.web.host,

crates/blend-web/src/middleware/auth.rs

@@ -1,11 +1,11 @@
-use crate::{context::Context, error::WebResult, router::JWT_COOKIE};
+use crate::{error::WebResult, router::JWT_COOKIE};
 use axum::{body::Body, extract::State, http::Request, middleware::Next, response::IntoResponse};
 use blend_crypto::jwt;
 use tower_cookies::Cookies;
 
 pub async fn middleware(
     cookies: Cookies,
-    State(ctx): State<Context>,
+    State(ctx): State<blend_context::Context>,
     req: Request<Body>,
     next: Next,
 ) -> WebResult<impl IntoResponse> {

crates/blend-web/src/router/feed.rs

@@ -1,71 +1,49 @@
-use crate::{context::Context, error::WebResult};
+use crate::error::WebResult;
 use axum::{
     extract::State,
     response::IntoResponse,
     routing::{get, post},
     Json, Router,
 };
-use blend_db::model;
-use serde::{Deserialize, Serialize};
+use blend_db::repo;
+use serde::Deserialize;
 use serde_json::json;
 
-pub fn router(ctx: Context) -> Router {
+pub fn router(ctx: blend_context::Context) -> Router {
     Router::new()
         .route("/", get(index))
-        .route("/create", get(create))
-        .route("/parse", post(parse))
+        .route("/add", post(add))
         // .route_layer(middleware::from_fn_with_state(
         //     ctx.clone(),
         //     crate::middleware::auth::middleware,
         // ))
         .with_state(ctx)
 }
 
-async fn index(State(ctx): State<Context>) -> WebResult<impl IntoResponse> {
-    let feeds: Vec<model::Feed> = sqlx::query_as!(model::Feed, "SELECT * FROM feeds")
-        .fetch_all(&ctx.db)
-        .await?;
-
+async fn index(State(ctx): State<blend_context::Context>) -> WebResult<impl IntoResponse> {
+    let feeds = repo::feed::FeedRepo::new(ctx).get_feeds().await?;
     Ok(Json(json!({ "data": feeds })))
 }
 
-async fn create(State(ctx): State<Context>) -> WebResult<impl IntoResponse> {
-    let mut conn = ctx.db.acquire().await?;
-
-    let title = "Rust Blog";
-    let url = "https://blog.rust-lang.org/feed.xml";
-
-    // Insert the task, then obtain the ID of this row
-    sqlx::query!(
-        r#"
-        INSERT INTO feeds ( title, url )
-        VALUES ( ?1, ?2 )
-        "#,
-        title,
-        url
-    )
-    .execute(&mut *conn)
-    .await?
-    .last_insert_rowid();
-
-    Ok("ok")
-}
-
 #[derive(Debug, Deserialize)]
-struct ParseFeedParams {
+struct AddFeedParams {
     url: String,
 }
 
-async fn parse(Json(data): Json<ParseFeedParams>) -> WebResult<impl IntoResponse> {
+async fn add(
+    State(ctx): State<blend_context::Context>,
+    Json(data): Json<AddFeedParams>,
+) -> WebResult<impl IntoResponse> {
     let parsed = blend_parse::parse_url(&data.url).await?;
 
-    let title = parsed.title.map(|title| title.content);
-
-    #[derive(Debug, Serialize)]
-    struct Response {
-        title: Option<String>,
-    }
+    let feed = repo::feed::FeedRepo::new(ctx)
+        .create_feed(repo::feed::CreateFeedParams {
+            title: parsed.title.map(|title| title.content),
+            url: Some("https://blog.rust-lang.org/feed.xml".to_string()),
+            published_at: parsed.published,
+            updated_at: parsed.updated,
+        })
+        .await?;
 
-    let res = Response { title };
-    Ok(Json(json!({"data": res})))
+    Ok(Json(json!({ "data": feed })))
 }

crates/blend-web/src/router/mod.rs

@@ -1,5 +1,4 @@
 use super::error::WebResult;
-use crate::context::Context;
 use axum::{response::IntoResponse, routing::get, Router};
 
 mod feed;
@@ -9,14 +8,14 @@ mod user;
 pub const JWT_COOKIE: &str = "blend_jwt";
 // pub const CSRF_COOKIE: &str = "blend_csrf";
 
-pub fn router(ctx: Context) -> Router {
+pub fn router(ctx: blend_context::Context) -> Router {
     Router::new()
         .with_state(ctx.clone())
         .nest("/api", api_router(ctx))
         .merge(ui::router())
 }
 
-pub fn api_router(ctx: Context) -> Router {
+pub fn api_router(ctx: blend_context::Context) -> Router {
     Router::new()
         .route("/", get(index))
         .with_state(ctx.clone())

crates/blend-web/src/router/user.rs

@@ -1,7 +1,6 @@
-use crate::context::Context;
 use axum::{middleware, response::IntoResponse, routing::get, Router};
 
-pub fn router(ctx: Context) -> Router {
+pub fn router(ctx: blend_context::Context) -> Router {
     Router::new()
         .route("/", get(index))
         .route_layer(middleware::from_fn_with_state(

src/main.rs

@@ -31,7 +31,7 @@ async fn main() -> error::BlendResult<()> {
         crate::args::Command::Web => {
             let blend = blend_config::parse(args.config)?;
             let db = blend_db::client::init(blend.clone()).await?;
-            let context = blend_web::context::Context { blend, db };
+            let context = blend_context::Context { blend, db };
 
             blend_web::serve(context).await?;
         }