feat: initialize thoughts-frontend with Next.js, TypeScript, and ESLint

- Add ESLint configuration for Next.js and TypeScript support.
- Create Next.js configuration file with standalone output option.
- Initialize package.json with scripts for development, build, and linting.
- Set up PostCSS configuration for Tailwind CSS.
- Add SVG assets for UI components.
- Create TypeScript configuration for strict type checking and module resolution.

thoughts-backend/tests/api/blog.rs

@@ -0,0 +1,30 @@
+use axum::{http::StatusCode, Router};
+use http_body_util::BodyExt;
+use serde_json::Value;
+
+use utils::testing::{make_get_request, make_post_request};
+
+pub(super) async fn test_post_blogs(app: Router) {
+    let response = make_post_request(
+        app,
+        "/blogs",
+        r#"{"author_id": 1, "title": "title", "content": "test"}"#.to_owned(),
+    )
+    .await;
+
+    assert_eq!(response.status(), StatusCode::CREATED);
+}
+
+pub(super) async fn test_get_blogs(app: Router) {
+    let response = make_get_request(app, "/blogs").await;
+    assert_eq!(response.status(), StatusCode::OK);
+
+    let body = response.into_body().collect().await.unwrap().to_bytes();
+    let result: Value = serde_json::from_slice(&body).unwrap();
+    assert_eq!(result["blogs"].as_array().unwrap().len(), 1);
+
+    let blog = &result["blogs"][0];
+    assert_eq!(blog["author_id"], 1);
+    assert_eq!(blog["title"], "title");
+    assert_eq!(blog["content"], "test");
+}

thoughts-backend/tests/api/mod.rs

@@ -0,0 +1,44 @@
+use api::setup_router;
+use utils::testing::setup_test_db;
+
+mod blog;
+mod root;
+mod user;
+
+use blog::*;
+use root::*;
+use user::*;
+
+#[tokio::test]
+async fn root_main() {
+    let db = setup_test_db("sqlite::root?mode=memory&cache=shared")
+        .await
+        .expect("Set up db failed!");
+
+    let app = setup_router(db);
+    test_root(app).await;
+}
+
+#[tokio::test]
+async fn user_main() {
+    let db = setup_test_db("sqlite::user?mode=memory&cache=shared")
+        .await
+        .expect("Set up db failed!");
+
+    let app = setup_router(db);
+    test_post_users(app.clone()).await;
+    test_post_users_error(app.clone()).await;
+    test_get_users(app).await;
+}
+
+#[tokio::test]
+async fn blog_main() {
+    let db = setup_test_db("sqlite::blog?mode=memory&cache=shared")
+        .await
+        .expect("Set up db failed!");
+
+    let app = setup_router(db);
+    test_post_users(app.clone()).await;
+    test_post_blogs(app.clone()).await;
+    test_get_blogs(app).await;
+}

thoughts-backend/tests/api/root.rs

@@ -0,0 +1,12 @@
+use axum::{http::StatusCode, Router};
+use http_body_util::BodyExt;
+
+use utils::testing::make_get_request;
+
+pub(super) async fn test_root(app: Router) {
+    let response = make_get_request(app, "/").await;
+    assert_eq!(response.status(), StatusCode::OK);
+
+    let body = response.into_body().collect().await.unwrap().to_bytes();
+    assert_eq!(&body[..], b"Hello, World from DB!");
+}

thoughts-backend/tests/api/user.rs

@@ -0,0 +1,36 @@
+use axum::{http::StatusCode, Router};
+use http_body_util::BodyExt;
+use serde_json::Value;
+
+use utils::testing::{make_get_request, make_post_request};
+
+pub(super) async fn test_post_users(app: Router) {
+    let response = make_post_request(app, "/users", r#"{"username": "test"}"#.to_owned()).await;
+    assert_eq!(response.status(), StatusCode::CREATED);
+
+    let body = response.into_body().collect().await.unwrap().to_bytes();
+    assert_eq!(&body[..], br#"{"id":1,"username":"test"}"#);
+}
+
+pub(super) async fn test_post_users_error(app: Router) {
+    let response = make_post_request(app, "/users", r#"{"username": "1"}"#.to_owned()).await;
+    assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
+
+    let body = response.into_body().collect().await.unwrap().to_bytes();
+    let result: Value = serde_json::from_slice(&body).unwrap();
+    assert_eq!(result["message"], "Validation error");
+    assert_eq!(result["details"]["username"][0]["code"], "length");
+    assert_eq!(result["details"]["username"][0]["message"], Value::Null);
+    assert_eq!(
+        result["details"]["username"][0]["params"]["min"],
+        Value::Number(2.into())
+    )
+}
+
+pub(super) async fn test_get_users(app: Router) {
+    let response = make_get_request(app, "/users").await;
+    assert_eq!(response.status(), StatusCode::OK);
+
+    let body = response.into_body().collect().await.unwrap().to_bytes();
+    assert_eq!(&body[..], br#"{"users":[{"id":1,"username":"test"}]}"#);
+}

thoughts-backend/tests/app/mod.rs

@@ -0,0 +1 @@
+mod persistence;

thoughts-backend/tests/app/persistence/blog.rs

@@ -0,0 +1,22 @@
+use sea_orm::{DatabaseConnection, Unchanged};
+
+use app::persistence::blog::create_blog;
+use models::domains::blog;
+use models::params::blog::CreateBlogParams;
+
+pub(super) async fn test_blog(db: &DatabaseConnection) {
+    let params = CreateBlogParams {
+        author_id: 1,
+        title: "title".to_string(),
+        content: "test".to_string(),
+    };
+
+    let blog = create_blog(db, params).await.expect("Create blog failed!");
+    let expected = blog::ActiveModel {
+        id: Unchanged(1),
+        author_id: Unchanged(1),
+        title: Unchanged("title".to_owned()),
+        content: Unchanged("test".to_owned()),
+    };
+    assert_eq!(blog, expected);
+}

thoughts-backend/tests/app/persistence/mod.rs

@@ -0,0 +1,26 @@
+use utils::testing::setup_test_db;
+
+mod blog;
+mod user;
+
+use blog::test_blog;
+use user::test_user;
+
+#[tokio::test]
+async fn user_main() {
+    let db = setup_test_db("sqlite::memory:")
+        .await
+        .expect("Set up db failed!");
+
+    test_user(&db).await;
+}
+
+#[tokio::test]
+async fn blog_main() {
+    let db = setup_test_db("sqlite::memory:")
+        .await
+        .expect("Set up db failed!");
+
+    test_user(&db).await;
+    test_blog(&db).await;
+}

thoughts-backend/tests/app/persistence/user.rs

@@ -0,0 +1,18 @@
+use sea_orm::{DatabaseConnection, Unchanged};
+
+use app::persistence::user::create_user;
+use models::domains::user;
+use models::params::user::CreateUserParams;
+
+pub(super) async fn test_user(db: &DatabaseConnection) {
+    let params = CreateUserParams {
+        username: "test".to_string(),
+    };
+
+    let user = create_user(db, params).await.expect("Create user failed!");
+    let expected = user::ActiveModel {
+        id: Unchanged(1),
+        username: Unchanged("test".to_owned()),
+    };
+    assert_eq!(user, expected);
+}

thoughts-backend/tests/mod.rs

@@ -0,0 +1,2 @@
+mod api;
+mod app;