feat(backend) update (unfinished)

backend/macros/src/include_str.rs

@@ -0,0 +1,24 @@
+/// Includes a UTF-8 encoded file as a string
+///
+/// The file is located relative to `CARGO_MANIFEST_DIR`.
+///
+/// # Example
+/// ```rust
+/// use macros::include_str_from_crate_root;
+///
+/// let str: &str = include_str_from_crate_root!("/query/scheme.sql");
+///
+// todo: impl
+// const PATH_PREFIX: &str = "/src";
+// let str: &str = include_str_from_crate_root!("{}/query/scheme.sql", PATH_PREFIX);
+/// ```
+#[macro_export]
+macro_rules! include_str_from_crate_root {
+    // ($path:literal $(, $($arg:tt)*)?) => {
+    // ($path:expr, $($args:tt)*) => {
+    //     include_str!(concat!(env!("CARGO_MANIFEST_DIR"), format_args!($path, $($args)*)))
+    // };
+    ($path:expr) => {
+        include_str!(concat!(env!("CARGO_MANIFEST_DIR"), $path))
+    };
+}

backend/macros/src/lib.rs

@@ -1 +1,2 @@
+mod include_str;
 mod log;

backend/server/Cargo.toml

@@ -5,11 +5,25 @@ edition = "2021"
 
 [dependencies]
 macros = { path = "../macros" }
+markdown = { path = "../markdown" }
 
-
-tracing = "0.1.41"
+axum = { version = "0.8.1", features = ["macros"] }
+tracing = { version = "0.1.41", features = ["log"] }
 git2 = "0.20.0"
+chrono = { version = "0.4.39", features = ["serde"] }
+cron = "0.15.0"
+sqlx = { version = "0.8.3", features = ["runtime-tokio", "tls-native-tls", "postgres", "chrono"] }
+serde_json = "1.0.133"
+serde = { version = "1.0.215", features = ["derive"] }
+tracing-subscriber = "0.3.18"
+tracing-appender = "0.2.3"
+dirs = "6.0.0"
+thiserror = "2.0.11"
+tokio = { version = "1.42.0", features = ["rt", "rt-multi-thread", "macros"] }
+dotenv = "0.15.0"
+uuid = { version = "1.13.2", features = ["v4"] }
+futures = "0.3.31"
 
 [build-dependencies]
 git2 = "0.20.0"
-chrono = "0.4.39"
+chrono = "0.4.39"

backend/server/build.rs

@@ -9,7 +9,8 @@ fn main() {
         .peel_to_commit()
         .expect("failed to get HEAD commit");
     let hash = commit.id().to_string();
-    let utc_date = Utc::now().date_naive().format("%Y%m%d").to_string();
-    let build_id = format!("{}@{}", utc_date, &hash[..8]);
+    let utc_timestamp = Utc::now().date_naive().format("%Y%m%d").to_string();
+    let pkg_version = env!("CARGO_PKG_VERSION");
+    let build_id = format!("{}:{}@{}", pkg_version, &hash[..8], utc_timestamp);
     println!("cargo:rustc-env=BUILD_ID={}", build_id);
 }

backend/server/schema.sql

@@ -1,32 +0,0 @@
-CREATE TABLE tag
-(
-    id          SERIAL PRIMARY KEY,
-    name        VARCHAR(20) UNIQUE NOT NULL,
-    description TEXT
-);
-
-CREATE TABLE category
-(
-    id          SERIAL PRIMARY KEY,
-    name        VARCHAR(20) UNIQUE NOT NULL,
-    description TEXT
-);
-
-CREATE TABLE post
-(
-    id             SERIAL PRIMARY KEY,
-    identifier     VARCHAR(50) UNIQUE              NOT NULL,
-    title          VARCHAR(255)                    NOT NULL,
-    subtitle       VARCHAR(255)                    NOT NULL,
-    published_date DATE                            NOT NULL,
-    last_update    DATE,
-    content        TEXT                            NOT NULL,
-
-    category       SERIAL REFERENCES category (id) NOT NULL
-);
-
-CREATE TABLE post_tag
-(
-    post SERIAL REFERENCES post (id),
-    tag  SERIAL REFERENCES tag (id)
-)

backend/server/src/init/database.rs

@@ -0,0 +1,42 @@
+use std::env;
+use std::error::Error;
+use std::str::FromStr;
+
+use crate::constants::config::database::{default_value, var_name};
+
+use sqlx::postgres::{PgConnectOptions, PgPoolOptions};
+use sqlx::{ConnectOptions, Pool, Postgres};
+use tracing::info;
+
+pub async fn init() -> Result<Pool<Postgres>, Box<dyn Error>> {
+    let db_connect_option = PgConnectOptions::from_str(&parse_db_uri())
+        .unwrap()
+        .disable_statement_logging();
+    Ok(PgPoolOptions::new()
+        .max_connections(1) // todo: temporary solution, to be fixed
+        .connect_with(db_connect_option)
+        .await?)
+}
+
+fn parse_db_uri() -> String {
+    env::var(var_name::URI).unwrap_or_else(|_| {
+        info!(
+            "`{}` env var is not set, \
+            using `{}`, `{}`, `{}`, `{}` and `{}`",
+            var_name::URI,
+            var_name::USERNAME,
+            var_name::PASSWORD,
+            var_name::HOST,
+            var_name::PORT,
+            var_name::DBNAME
+        );
+        let postgres_user = env::var(var_name::USERNAME).unwrap_or(default_value::USERNAME.into());
+        let postgres_password =
+            env::var(var_name::PASSWORD).unwrap_or(default_value::PASSWORD.into());
+        let db_host = env::var(var_name::HOST).unwrap_or(default_value::HOST.into());
+        let db_port = env::var(var_name::PORT).unwrap_or(default_value::PORT.into());
+        let postgres_db = env::var(var_name::DBNAME).unwrap_or(default_value::DBNAME.into());
+        let db_type = default_value::DATABASE_TYPE;
+        format!("{db_type}://{postgres_user}:{postgres_password}@{db_host}:{db_port}/{postgres_db}")
+    })
+}

backend/server/src/init/logger.rs

@@ -0,0 +1,107 @@
+use std::path::Path;
+use std::{env, io};
+
+use crate::constants::config::general::{default_value, var_name};
+
+use chrono::Local;
+use dirs::home_dir;
+use tracing::info;
+use tracing_appender::{non_blocking, non_blocking::WorkerGuard, rolling};
+use tracing_subscriber::{
+    filter::LevelFilter, fmt, fmt::format::Writer, fmt::time::FormatTime, fmt::MakeWriter,
+    layer::SubscriberExt, Layer, Registry,
+};
+
+struct LocalTimer;
+
+impl FormatTime for LocalTimer {
+    fn format_time(&self, w: &mut Writer<'_>) -> std::fmt::Result {
+        write!(
+            w,
+            "{}",
+            Local::now().format(crate::constants::time::DEFAULT_TIME_FORMAT)
+        )
+    }
+}
+
+type _LogWriter = dyn for<'writer> MakeWriter<'writer, Writer = dyn io::Write + 'static> + 'static;
+
+pub fn init() -> (WorkerGuard, WorkerGuard) {
+    let log_path = match env::var(var_name::LOG_DIR) {
+        Ok(path) => Path::new(&path).to_path_buf(),
+        Err(_) => {
+            let path = if let Ok(default_log_path) = env::var(var_name::WORK_DIR) {
+                expand_home_path(default_log_path)
+            } else {
+                let fallback_path = expand_home_path(default_value::WORK_DIR.to_string());
+                println!(
+                    "[warn] unset env var `{}` and `{}`, trying to log on fallback path: {}/log",
+                    var_name::LOG_DIR,
+                    var_name::WORK_DIR,
+                    fallback_path
+                );
+                fallback_path
+            };
+            Path::new(&path).join("log")
+        }
+    };
+
+    let (info_log_writer, info_guard) = non_blocking(rolling::never(&log_path, "info.log"));
+    let (err_log_writer, error_guard) = non_blocking(rolling::never(&log_path, "error.log"));
+
+    let info_format = tracing_subscriber::fmt::format()
+        .with_level(true)
+        .with_target(true)
+        .with_source_location(true)
+        .with_ansi(false);
+    let err_format = tracing_subscriber::fmt::format()
+        .with_level(true)
+        .with_target(true)
+        .with_source_location(true)
+        .with_ansi(false);
+    let stdout_format = tracing_subscriber::fmt::format()
+        .with_level(true)
+        .with_target(true)
+        .with_source_location(true)
+        .with_timer(LocalTimer);
+
+    let subscribers = Registry::default()
+        .with(
+            fmt::Layer::default()
+                .with_writer(info_log_writer)
+                .event_format(info_format),
+        )
+        .with(
+            fmt::Layer::default()
+                .with_writer(err_log_writer)
+                .event_format(err_format)
+                .with_filter(LevelFilter::ERROR),
+        )
+        .with(
+            fmt::Layer::default()
+                .with_writer(io::stdout)
+                .with_ansi(true)
+                .event_format(stdout_format),
+        );
+
+    tracing::subscriber::set_global_default(subscribers)
+        .expect("[fatal] failed to setup logging system");
+
+    info!("logging to dir: {}", log_path.to_str().unwrap());
+
+    (info_guard, error_guard)
+}
+
+fn expand_home_path(path: String) -> String {
+    if path.starts_with('~') {
+        let home_path = home_dir()
+            .unwrap_or_else(|| panic!("[fatal] unable to locate home dir when parsing env `{}`, try to use absolute path instead", var_name::WORK_DIR));
+        home_path
+            .join(path.strip_prefix("~/").unwrap())
+            .into_os_string()
+            .into_string()
+            .unwrap()
+    } else {
+        path
+    }
+}

backend/server/src/init/misc.rs

@@ -0,0 +1,14 @@
+use git2::opts::{set_server_connect_timeout_in_milliseconds, set_server_timeout_in_milliseconds};
+use tracing::warn;
+
+pub fn init() {
+    // git2 option
+    unsafe {
+        if let Err(e) = set_server_connect_timeout_in_milliseconds(10_000) {
+            warn!("failed to set git2 server connect timeout: {}", e);
+        }
+        if let Err(e) = set_server_timeout_in_milliseconds(60_000) {
+            warn!("failed to set git2 server timeout: {}", e);
+        }
+    }
+}

backend/server/src/init/mod.rs

@@ -0,0 +1,50 @@
+mod database;
+pub mod logger;
+mod misc;
+
+use std::{env, panic};
+
+use crate::modules::{blog::Blog, ModuleTree};
+use macros::error_panic;
+
+use tracing::info;
+
+pub fn load_env() {
+    if let Some(env_file) = env::args().nth(1) {
+        match dotenv::from_filename(&env_file) {
+            Ok(_) => {
+                println!("[info] env loaded from {}, starting up", env_file);
+            }
+            Err(e) => {
+                panic!("[fatal] failed to read {}: {}", env_file, e);
+            }
+        }
+    } else {
+        println!("[info] no .env file referred, starting up")
+    }
+}
+
+pub async fn start() {
+    misc::init();
+
+    // connect database
+    let db_pool = match database::init().await {
+        Ok(pool) => {
+            info!("database connection pool initialized");
+            pool
+        }
+        Err(e) => {
+            error_panic!("database connection pool failed to initialize: {}", e);
+        }
+    };
+
+    // // schema init
+    // schema::init(&db_pool).await;
+
+    ModuleTree::new()
+        .add_module(Blog {
+            db_handler: db_pool,
+        })
+        .blocking_serve()
+        .await
+}

backend/server/src/main.rs

@@ -1,7 +1,23 @@
+#[allow(dead_code)]
 mod constants;
 
+#[allow(dead_code)]
+mod scheduler;
+
+mod init;
+mod modules;
+mod utils;
+
+use crate::init::{logger, start};
+
 const BUILD_ID: &str = env!("BUILD_ID");
 
-fn main() {
+#[tokio::main]
+async fn main() {
     println!("{}", BUILD_ID);
+
+    init::load_env();
+    let _guards = logger::init();
+
+    start().await;
 }

backend/server/src/modules/blog/api/get_page_count/mod.rs

@@ -0,0 +1,25 @@
+use crate::constants::blog::PAGE_SIZE;
+
+use axum::{extract::State, Json};
+use serde_json::{json, Value};
+use sqlx::{query, PgPool, Row};
+use tracing::error;
+
+const GET_PAGE_COUNT_QUERY: &str = include_str!("post_page_count.sql");
+
+pub async fn handler(State(db_connection): State<PgPool>) -> Result<Json<Value>, Json<Value>> {
+    match query(GET_PAGE_COUNT_QUERY)
+        .bind(PAGE_SIZE as i64)
+        .fetch_one(&db_connection)
+        .await
+    {
+        Ok(res) => {
+            let res: i32 = res.get("count");
+            Ok(Json::from(json!({"res": res})))
+        }
+        Err(e) => {
+            error!("failed to get blog page count: {}", e.to_string());
+            Err(Json::from(json!({"error": e.to_string()})))
+        }
+    }
+}

backend/server/src/modules/blog/api/get_page_count/post_page_count.sql

@@ -0,0 +1,2 @@
+SELECT cast(ceil(count(*) / cast($1 AS FLOAT)) AS INTEGER) AS count
+FROM posts;

backend/server/src/modules/blog/api/get_post/mod.rs

@@ -0,0 +1,30 @@
+use axum::response::IntoResponse;
+use axum::{
+    extract::{Path, State},
+    Json,
+};
+use serde_json::json;
+use sqlx::PgPool;
+
+const GET_POST_BY_I64_ID: &str = include_str!("get_post_by_i64_id.sql");
+const GET_POST_BY_STR_ID: &str = include_str!("get_post_by_str_id.sql");
+
+pub async fn handler(
+    State(db_connection): State<PgPool>,
+    Path(identifier): Path<String>,
+) -> impl IntoResponse {
+    let post = if let Ok(id) = identifier.parse::<i64>() {
+        select_post_with_i64_id(&db_connection, id).await
+    } else {
+        select_post_with_str_id(&db_connection, &identifier).await
+    };
+    Json::from(json!({"res": "ok"})).into_response()
+}
+
+async fn select_post_with_i64_id(db: &PgPool, id: i64) {
+    todo!()
+}
+
+async fn select_post_with_str_id(db: &PgPool, id: &str) {
+    todo!()
+}

backend/server/src/modules/blog/api/get_post_list.rs

@@ -0,0 +1,130 @@
+use std::error::Error;
+
+use crate::constants::blog::PAGE_SIZE;
+
+use axum::{extract::Query, extract::State, http::StatusCode, Json};
+use chrono::{DateTime, Utc};
+use futures::future::join_all;
+use serde::Deserialize;
+use serde_json::{json, Map, Value};
+use sqlx::{postgres::PgRow, query, PgPool, Row};
+use tracing::error;
+use uuid::Uuid;
+
+#[derive(Deserialize)]
+pub struct Params {
+    page: Option<u32>,
+}
+
+#[axum::debug_handler]
+pub async fn get_post_list(
+    State(db_connection): State<PgPool>,
+    Query(params): Query<Params>,
+) -> Result<Json<Value>, (StatusCode, Json<Value>)> {
+    let search_param_page = params.page.unwrap_or(1);
+    if search_param_page < 1 {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            Json::from(json!({"error": "`page` should be greater than 0"})),
+        ));
+    }
+
+    let offset = PAGE_SIZE * (search_param_page - 1);
+
+    let post_list = sqlx::query("SELECT * FROM post ORDER BY first_update DESC LIMIT $1 OFFSET $2")
+        .bind(PAGE_SIZE as i32)
+        .bind(offset as i32)
+        .fetch_all(&db_connection)
+        .await;
+    let post_list = match post_list {
+        Ok(post_list) => post_list,
+        Err(e) => {
+            error!(
+                "Database query error on fetching post list: {}",
+                e.to_string()
+            );
+            return Err((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json::from(json!({"error": e.to_string()})),
+            ));
+        }
+    };
+
+    let mut res = Vec::new();
+    let posts: Vec<_> = post_list
+        .into_iter()
+        .map(|post| async { analyze_post(&db_connection, post).await })
+        .collect();
+    let posts = join_all(posts).await;
+    for post in posts {
+        match post {
+            Ok(p) => res.push(p),
+            Err(e) => {
+                return Err((
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json::from(json!(("error", e.to_string()))),
+                ))
+            }
+        }
+    }
+
+    // res.insert("posts".to_string(), Value::from(posts));
+    Ok(Json::from(Value::from(res)))
+}
+
+async fn analyze_post(db_connection: &PgPool, post: PgRow) -> Result<Value, Box<dyn Error + Send>> {
+    let post_id: Uuid = post.get("post_id");
+    let tags = fetch_post_tags(db_connection, post_id).await;
+    let meta = fetch_post_meta(db_connection, post_id).await.unwrap();
+    let header_img = meta.get("header_img");
+    let last_update = meta.get("last_update");
+
+    Ok(json!({
+        "post_id": post_id.to_string(),
+        "title": post.get::<String, _>("title"),
+        "category": post.get::<String, _>("category"),
+        "header_img": header_img,
+        "sub_title": post.get::<String, _>("sub_title"),
+        "summary": post.get::<String, _>("summary"),
+        "last_update": last_update,
+        "first_update": post.get::<DateTime<Utc>, _>("first_update"),
+        "tags": tags,
+    }))
+}
+
+async fn fetch_post_meta(db_connection: &PgPool, post_id: Uuid) -> Option<Value> {
+    match query(
+        r#"
+SELECT jsonb_strip_nulls(to_jsonb(t.*)) - 'post_id' AS meta
+FROM meta t
+WHERE post_id = $1;
+        "#,
+    )
+    .bind(post_id)
+    .fetch_one(db_connection)
+    .await
+    {
+        Ok(value) => Some(value.get::<Value, _>("meta")),
+        Err(e) => {
+            error!(
+                "Database error on Reading `{}` from table `{}`: <{}>: {}",
+                "post meta data",
+                "meta",
+                post_id.to_string(),
+                e.to_string()
+            );
+            None
+        }
+    }
+}
+
+async fn fetch_post_tags(db_connection: &PgPool, post_id: Uuid) -> Vec<String> {
+    match query("SELECT tag FROM Tag WHERE post_id = $1")
+        .bind(post_id)
+        .fetch_all(db_connection)
+        .await
+    {
+        Ok(res) => res.iter().map(|tag| tag.get::<String, _>("tag")).collect(),
+        Err(_) => vec![],
+    }
+}

backend/server/src/modules/blog/api/mod.rs

@@ -0,0 +1,3 @@
+pub mod get_page_count;
+pub mod get_post;
+// pub mod get_post_list;

backend/server/src/modules/blog/cron/check_update/error.rs

@@ -0,0 +1,49 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum PostIdxError {
+    #[error("missing essential field `{}` for file `{}`", field, filename)]
+    MissingField { field: String, filename: String },
+
+    #[error(
+        "invalid field `{}` for file `{}`, <{}>: {}",
+        field_name,
+        filename,
+        err_field,
+        msg
+    )]
+    InvalidField {
+        field_name: String,
+        err_field: String,
+        filename: String,
+        msg: String,
+    },
+
+    #[error(
+        "database error on writing `{}` to table `{}`: <{}>: {}",
+        data_desc,
+        db_table,
+        id,
+        msg
+    )]
+    DBWriteFailure {
+        data_desc: String,
+        db_table: String,
+        id: String,
+        msg: String,
+    },
+
+    #[error(
+        "Database error on Reading `{}` from table `{}`: <{}>: {}",
+        data_desc,
+        db_table,
+        id,
+        msg
+    )]
+    DBReadFailure {
+        data_desc: String,
+        db_table: String,
+        id: String,
+        msg: String,
+    },
+}

backend/server/src/modules/blog/cron/check_update/index.rs

@@ -0,0 +1,353 @@
+use std::error::Error;
+use std::path::Path;
+
+use crate::{
+    modules::blog::cron::check_update::utils::get_md_file_basename,
+    modules::blog::cron::check_update::{error::PostIdxError, utils::parse_date},
+};
+use markdown::MdFile;
+
+use sqlx::{query, PgPool, Pool, Postgres, Row};
+use tokio::runtime::Runtime;
+use tracing::{info, warn};
+
+async fn base(db_connection: &PgPool, post: &MdFile) -> Result<(), PostIdxError> {
+    let post_id = post.file_id;
+    let title = match post.meta.get("title") {
+        None => {
+            return Err(PostIdxError::MissingField {
+                field: "title".to_string(),
+                filename: post.filename.clone(),
+            })
+        }
+        Some(title) => title.as_str().unwrap_or_else(|| {
+            warn!("invalid title for `{}`", &post.filename);
+            "invalid title"
+        }),
+    };
+    let sub_title = post
+        .meta
+        .get("sub_title")
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
+    let summary = post
+        .meta
+        .get("summary")
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
+    let content = post.content.as_str();
+    let category = match post.meta.get("category") {
+        None => {
+            return Err(PostIdxError::MissingField {
+                field: "category".to_string(),
+                filename: post.filename.clone(),
+            })
+        }
+        Some(title) => title.as_str().unwrap_or_else(|| {
+            warn!("invalid category for `{}`", &post.filename);
+            "invalid category"
+        }),
+    };
+    let last_update = {
+        if let Some(last_update) = post.meta.get("last_update") {
+            match parse_date(last_update.as_str().unwrap()) {
+                Ok(date) => Some(date),
+                Err(e) => {
+                    return Err(PostIdxError::InvalidField {
+                        field_name: "last_update".to_string(),
+                        err_field: last_update.to_string(),
+                        filename: post.filename.clone(),
+                        msg: e.to_string(),
+                    })
+                }
+            }
+        } else {
+            None
+        }
+    };
+    let first_update = match post.meta.get("date") {
+        None => {
+            return Err(PostIdxError::MissingField {
+                field: "date".to_string(),
+                filename: post.filename.clone(),
+            })
+        }
+        Some(first_update) => match parse_date(first_update.as_str().unwrap()) {
+            Ok(date) => date,
+            Err(e) => {
+                return Err(PostIdxError::InvalidField {
+                    field_name: "date".to_string(),
+                    err_field: first_update.to_string(),
+                    filename: post.filename.clone(),
+                    msg: e.to_string(),
+                })
+            }
+        },
+    };
+    let filename = get_md_file_basename(&post.filename);
+
+    if let Err(e) = query(
+        r##"
+INSERT INTO Post (post_id, title, summary, content, last_update, first_update, sub_title, category, filename)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+ON CONFLICT (post_id) DO
+UPDATE SET
+    title = EXCLUDED.title,
+    summary = EXCLUDED.summary,
+    content = EXCLUDED.content,
+    last_update = EXCLUDED.last_update,
+    first_update = EXCLUDED.first_update,
+    sub_title = EXCLUDED.sub_title,
+    category = EXCLUDED.category,
+    filename = EXCLUDED.filename;
+        "##,
+    )
+        .bind(post_id)
+        .bind(title)
+        .bind(summary)
+        .bind(content)
+        .bind(last_update)
+        .bind(first_update)
+        .bind(sub_title)
+        .bind(category)
+        .bind(filename)
+        .execute(db_connection)
+        .await
+    {
+        return Err(
+            PostIdxError::DBWriteFailure {
+                data_desc: "post base information".to_string(),
+                db_table: "Post".to_string(),
+                id: post_id.to_string(),
+                msg: e.to_string(),
+            }
+        );
+    }
+    Ok(())
+}
+
+async fn tag(db_connection: &PgPool, post: &MdFile) -> Result<(), PostIdxError> {
+    if let Some(tags_string) = post.meta.get("tags").to_owned() {
+        let tags = match tags_string.as_array().map(|vec| {
+            vec.iter()
+                .map(|val| val.as_str().unwrap())
+                .collect::<Vec<_>>()
+        }) {
+            None => {
+                return Err(PostIdxError::MissingField {
+                    field: "tags".to_string(),
+                    filename: post.filename.clone(),
+                })
+            }
+            Some(val) => val,
+        };
+
+        let post_id = post.file_id;
+
+        // remove old record
+        if let Err(e) = query("DELETE FROM Tag WHERE post_id = $1")
+            .bind(post_id)
+            .execute(db_connection)
+            .await
+        {
+            return Err(PostIdxError::DBWriteFailure {
+                data_desc: "post tag information".to_string(),
+                db_table: "Tag".to_string(),
+                id: post_id.to_string(),
+                msg: e.to_string(),
+            });
+        }
+
+        // add new record
+        for tag in tags {
+            match query("INSERT INTO Tag VALUES ($1, $2);")
+                .bind(post_id)
+                .bind(tag)
+                .execute(db_connection)
+                .await
+            {
+                Ok(_) => {}
+                Err(e) => {
+                    return Err(PostIdxError::DBWriteFailure {
+                        data_desc: "post tag information".to_string(),
+                        db_table: "Tag".to_string(),
+                        id: post_id.to_string(),
+                        msg: e.to_string(),
+                    })
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+async fn hash(db_connection: &PgPool, post: &MdFile) -> Result<bool, PostIdxError> {
+    let base64_form = post.hash.clone();
+    match query("SELECT hash FROM Hash WHERE post_id = $1")
+        .bind(post.file_id)
+        .fetch_optional(db_connection)
+        .await
+    {
+        Ok(row) => {
+            let db_record: String = match row {
+                None => "".to_string(),
+                Some(row) => row.try_get("hash").unwrap_or("".to_string()),
+            };
+            if base64_form == db_record {
+                Ok(false)
+            } else {
+                if let Err(e) = query(
+                    r#"
+INSERT INTO Hash (post_id, hash) VALUES ($1, $2)
+    ON CONFLICT (post_id) DO UPDATE SET hash = EXCLUDED.hash"#,
+                )
+                .bind(post.file_id)
+                .bind(&base64_form)
+                .execute(db_connection)
+                .await
+                {
+                    return Err(PostIdxError::DBWriteFailure {
+                        data_desc: "post hash".to_string(),
+                        db_table: "Hash".to_string(),
+                        id: post.file_id.to_string(),
+                        msg: e.to_string(),
+                    });
+                }
+                Ok(true)
+            }
+        }
+        Err(e) => Err(PostIdxError::DBReadFailure {
+            data_desc: "post hash".to_string(),
+            db_table: "Hash".to_string(),
+            id: post.file_id.to_string(),
+            msg: e.to_string(),
+        }),
+    }
+}
+
+async fn meta(db_connection: &PgPool, post: &MdFile) -> Result<(), PostIdxError> {
+    if let Err(e) = query(
+        // todo: sanitization
+        format!(
+            r#"
+DO
+$$
+    DECLARE
+        _post_id        UUID  := '{}';
+        _meta_cols      JSONB := '{}';
+        _exists         BOOLEAN;
+        _col_name       TEXT;
+        _col_value      TEXT;
+        _sql            TEXT;
+        _insert_columns TEXT  := 'post_id';
+        _insert_values  TEXT  := quote_literal(_post_id);
+        _update_set     TEXT  := '';
+        _blacklist      TEXT[] := ARRAY['tags'];
+    BEGIN
+        SELECT EXISTS(SELECT 1 FROM meta WHERE post_id = _post_id) INTO _exists;
+
+        FOR _col_name, _col_value IN SELECT key, value FROM jsonb_each_text(_meta_cols)
+            LOOP
+                IF _col_name = ANY(_blacklist) THEN
+                    CONTINUE;
+                END IF;
+
+                IF NOT EXISTS (SELECT 1
+                               FROM information_schema.columns
+                               WHERE table_name = 'meta'
+                                 AND column_name = _col_name
+                                 -- may change in the future
+                                 AND table_schema = 'public') THEN
+                    _sql := 'ALTER TABLE meta ADD COLUMN ' || quote_ident(_col_name) || ' TEXT';
+                    EXECUTE _sql;
+                END IF;
+                _insert_columns := _insert_columns || ', ' || quote_ident(_col_name);
+                _insert_values := _insert_values || ', ' || quote_literal(_col_value);
+                _update_set := _update_set || ', ' || quote_ident(_col_name) || ' = ' || quote_literal(_col_value);
+            END LOOP;
+
+        _update_set := substring(_update_set FROM 3);
+
+        IF _exists THEN
+            _sql := 'UPDATE meta SET ' || _update_set || ' WHERE post_id = ' || quote_literal(_post_id);
+            EXECUTE _sql;
+        ELSE
+            _sql := 'INSERT INTO meta (' || _insert_columns || ') VALUES (' || _insert_values || ')';
+            EXECUTE _sql;
+        END IF;
+    END;
+$$ LANGUAGE plpgsql;
+        "#, post.file_id.to_string().as_str(), post.meta
+        ).as_str()
+    )
+        .execute(db_connection)
+        .await {
+        Err(PostIdxError::DBWriteFailure {
+            data_desc: "post meta data".to_string(),
+            db_table: "Meta".to_string(),
+            id: post.file_id.to_string(),
+            msg: e.to_string(),
+        })
+    } else {
+        Ok(())
+    }
+}
+
+pub async fn index_file(path: &Path, db_conn: &Pool<Postgres>) -> Result<(), Box<dyn Error>> {
+    let md_file = MdFile::from_file(path)?;
+
+    async fn trail(db_conn: &Pool<Postgres>, md_file: &MdFile) -> Result<(), PostIdxError> {
+        base(db_conn, md_file).await?;
+        tag(db_conn, md_file).await?;
+        meta(db_conn, md_file).await?;
+        hash(db_conn, md_file).await.map(|_| ())
+    }
+    let mut cnt = 5;
+
+    while let Err(e) = trail(db_conn, &md_file).await {
+        match e {
+            PostIdxError::DBWriteFailure { .. } => {
+                cnt -= 1;
+            }
+            PostIdxError::DBReadFailure { .. } => {
+                cnt -= 1;
+            }
+            _ => return Err(e.into()),
+        }
+        if cnt <= 0 {
+            return Err(e.into());
+        }
+    }
+
+    info!("indexed markdown file: {}", path.display());
+    Ok(())
+}
+
+pub fn drop_index(file_basename: &str, db_conn: &Pool<Postgres>) -> Result<(), Box<dyn Error>> {
+    let rt = Runtime::new().unwrap();
+    rt.block_on(async {
+        if let Err(e) = query(
+            r#"
+WITH deleted_post AS (
+    DELETE FROM post
+    WHERE id = (SELECT id FROM post WHERE filename = $1)
+    RETURNING id
+)
+DELETE FROM tag WHERE post_id IN (SELECT id FROM deleted_post);
+DELETE FROM meta WHERE post_id IN (SELECT id FROM deleted_post);
+DELETE FROM hash WHERE post_id IN (SELECT id FROM deleted_post);
+    "#,
+        )
+        .bind(file_basename)
+        .execute(db_conn)
+        .await
+        {
+            Err(Box::from(
+                format!("failed to drop index: {}", e).to_string(),
+            ))
+        } else {
+            Ok(())
+        }
+    })
+}

backend/server/src/modules/blog/cron/check_update/mod.rs

@@ -0,0 +1,148 @@
+use std::{
+    env,
+    fs::remove_dir_all,
+    path::{Path, PathBuf},
+};
+
+use crate::{
+    constants::config::general::{default_value, var_name},
+    modules::blog::cron::check_update::{
+        index::drop_index,
+        utils::{expand_path, get_md_file_basename, index_files, search_md},
+    },
+    utils::git,
+};
+use macros::panic_with_log;
+
+use git2::{Delta, Repository};
+use sqlx::{Pool, Postgres};
+use tracing::{error, info, warn, Level};
+
+mod error;
+mod index;
+mod utils;
+
+pub fn task(db_connection: &Pool<Postgres>) {
+    // init
+    let git_work_dir = {
+        let path = if let Ok(default_log_path) = env::var(var_name::WORK_DIR) {
+            expand_path(default_log_path)
+        } else {
+            let fallback_path = expand_path(default_value::WORK_DIR.to_string());
+            warn!(
+                "unset env var `{}`, using default path: {}/blog_git",
+                var_name::WORK_DIR,
+                fallback_path
+            );
+            fallback_path
+        };
+        Path::new(&path).join("blog_git")
+    };
+
+    // clone & check update
+
+    let git_url = match env::var(var_name::BLOG_GIT_URL) {
+        Ok(url) => url,
+        Err(e) => {
+            panic_with_log!(
+                Level::ERROR,
+                "failed to read `{}`: {}",
+                var_name::BLOG_GIT_URL,
+                e
+            )
+        }
+    };
+    let git_remote_name = env::var(var_name::BLOG_GIT_REMOTE_NAME)
+        .unwrap_or(default_value::BLOG_GIT_REMOTE_NAME.to_string());
+    let git_remote_branch = env::var(var_name::BLOG_GIT_REMOTE_BRANCH)
+        .unwrap_or(default_value::BLOG_GIT_REMOTE_BRANCH.to_string());
+
+    match Repository::open(&git_work_dir) {
+        Ok(repo) => {
+            // prevent git remote url mismatch (clean cache)
+            match repo.find_remote(&git_remote_name) {
+                Ok(remote) => {
+                    if remote.url().is_some_and(|url| url != git_url) {
+                        remove_dir_all(&git_work_dir).unwrap();
+                        warn!("blog content git({}) url mismatch, reinitialized", &git_url);
+                        return;
+                    }
+                }
+                Err(e) => {
+                    remove_dir_all(&git_work_dir).unwrap();
+                    error!(
+                        "unexpected error on indexing blog content git({}), reinitialized: {}",
+                        &git_url, e
+                    );
+                }
+            }
+
+            match git::sync(&git_remote_name, &git_remote_branch, &repo) {
+                Ok(updates) => {
+                    if !updates.is_empty() {
+                        // incremental update
+                        info!(
+                            "blog content git({}) update detected: {:?}",
+                            &git_url, updates
+                        );
+
+                        let mut update_md: Vec<PathBuf> = vec![];
+
+                        for update in updates {
+                            if [Delta::Deleted, Delta::Untracked].contains(&update.status) {
+                                if let Some(path) = &update.old_path {
+                                    if drop_index(
+                                        &get_md_file_basename(
+                                            path.file_name().unwrap().to_str().unwrap(),
+                                        ),
+                                        db_connection,
+                                    )
+                                    .is_ok()
+                                    {
+                                        info!(
+                                            "blog content git({}) file `{}` is detected as deleted/untracked, index dropped",
+                                            &git_url,
+                                            &path.display()
+                                        );
+                                    } else {
+                                        error!(
+                                            "blog content git({}) file `{}` is detected as deleted/untracked, failed to drop index",
+                                            &git_url,
+                                            &path.display()
+                                        )
+                                    }
+                                }
+                            } else if let Some(path) = &update.new_path {
+                                if path.components().any(|comp| comp.as_os_str() == "posts")
+                                    && path.extension().is_some_and(|ext| ext == "md")
+                                {
+                                    update_md.push(path.to_path_buf());
+                                }
+                            }
+                        }
+
+                        index_files(&update_md, db_connection);
+                    }
+                }
+                Err(e) => {
+                    error!(
+                        "failed to sync blog content git({}) updates: {}",
+                        &git_url, e
+                    );
+                }
+            }
+        }
+        Err(_) => {
+            match Repository::clone(&git_url, &git_work_dir) {
+                Ok(_repo) => {
+                    // full repo index
+                    let files = search_md(git_work_dir.join("posts"));
+                    index_files(&files, db_connection);
+                }
+                Err(e) => {
+                    error!("failed to clone blog content git({}): {}", &git_url, e);
+                }
+            }
+        }
+    };
+}

backend/server/src/modules/blog/cron/check_update/utils.rs

@@ -0,0 +1,88 @@
+use std::path::PathBuf;
+
+use crate::{
+    constants::{
+        config::general::{default_value, var_name},
+        time::DEFAULT_DATE_FORMAT,
+    },
+    modules::blog::cron::check_update::index::index_file,
+};
+
+use chrono::{DateTime, FixedOffset, ParseResult};
+use dirs::home_dir;
+use futures::{executor::block_on, future::join_all};
+use sqlx::{Pool, Postgres};
+use tokio::{runtime::Runtime, spawn};
+use tracing::{error, warn};
+
+pub fn search_md(entry: PathBuf) -> Vec<PathBuf> {
+    if entry.ends_with(".git") {
+        return vec![];
+    }
+    if entry.is_dir() {
+        if let Ok(files) = entry.read_dir() {
+            files
+                .flat_map(|file| {
+                    let file_path = file.unwrap().path();
+                    search_md(file_path)
+                })
+                .collect()
+        } else {
+            vec![]
+        }
+    } else if entry.extension().is_some_and(|ext| ext == "md") {
+        vec![entry]
+    } else {
+        vec![]
+    }
+}
+
+pub fn index_files(files: &[PathBuf], db_conn: &Pool<Postgres>) {
+    let rt = Runtime::new().unwrap();
+    rt.block_on(async {
+        let files_clone = files.to_owned();
+        let handlers = files_clone
+            .into_iter()
+            .map(|file: PathBuf| {
+                let conn_clone = db_conn.clone();
+                spawn(async move {
+                    if let Err(e) = index_file(&file, &conn_clone).await {
+                        error!("failed to index markdown file `{}`: {}", file.display(), e);
+                    }
+                })
+            })
+            .collect::<Vec<_>>();
+
+        block_on(join_all(handlers));
+    });
+}
+
+pub fn expand_path(path: String) -> String {
+    if path.starts_with('~') {
+        home_dir()
+            .map(|dir| {
+                dir.join(path.strip_prefix("~/").unwrap())
+                    .into_os_string()
+                    .into_string()
+                    .unwrap()
+            })
+            .unwrap_or_else(|| {
+                warn!(
+                    "failed to parse env var `{}`, using default value `{}`",
+                    var_name::WORK_DIR,
+                    default_value::WORK_DIR
+                );
+                default_value::WORK_DIR.to_string()
+            })
+    } else {
+        path
+    }
+}
+
+pub fn parse_date(date_str: &str) -> ParseResult<DateTime<FixedOffset>> {
+    DateTime::parse_from_str(format!("{}T120000", date_str).as_str(), DEFAULT_DATE_FORMAT)
+}
+
+pub fn get_md_file_basename(f_name: &str) -> String {
+    f_name.replace(".md", "")
+}

backend/server/src/modules/blog/cron/mod.rs

@@ -0,0 +1 @@
+// pub mod check_update;

backend/server/src/modules/blog/mod.rs

@@ -0,0 +1,52 @@
+mod api;
+mod cron;
+
+use crate::{
+    modules::{
+        blog::{
+            api::{
+                get_page_count,
+                get_post,
+                // get_post_list::get_post_list,
+            },
+            // cron::check_update,
+        },
+        Module,
+    },
+    scheduler::tasks::CronTask,
+};
+
+use axum::{routing::get, Router};
+use sqlx::PgPool;
+
+const MOUNT_POINT: &str = "/blog";
+
+pub struct Blog {
+    pub db_handler: PgPool,
+}
+
+impl Module for Blog {
+    fn get_server_router(&self) -> Router {
+        let db_handler = self.db_handler.clone();
+        // todo: move resource init to new func
+        // todo: remove debug comment
+        Router::new()
+            // .route("/get_post_list", get(get_post_list))
+            .route("/get_page_count", get(get_page_count::handler))
+            .route("/get_post/{identifier}", get(get_post::handler))
+            .with_state(db_handler)
+    }
+
+    fn get_mount_point(&self) -> &'static str {
+        MOUNT_POINT
+    }
+
+    fn get_cron_tasks(&self) -> Vec<Box<dyn CronTask>> {
+        // let db_handler = self.db_handler.clone();
+        vec![
+            // BasicTask::new(move || check_update::task(&db_handler), "0/15 * * * * *")
+            //     .unwrap()
+            //     .to_task(),
+        ]
+    }
+}

backend/server/src/modules/blog/schema.sql

@@ -0,0 +1,41 @@
+CREATE TABLE tags
+(
+    id          SERIAL PRIMARY KEY,
+    name        VARCHAR(20) UNIQUE NOT NULL,
+    description TEXT
+);
+
+CREATE TABLE categories
+(
+    id          SERIAL PRIMARY KEY,
+    name        VARCHAR(20) UNIQUE NOT NULL,
+    description TEXT
+);
+
+CREATE TABLE posts
+(
+    id             SERIAL PRIMARY KEY,
+    identifier     VARCHAR(50) UNIQUE                NOT NULL,
+    title          VARCHAR(255)                      NOT NULL,
+    subtitle       VARCHAR(255)                      NOT NULL,
+    published_date DATE                              NOT NULL,
+    last_update    DATE,
+    content        TEXT                              NOT NULL,
+
+    category       SERIAL REFERENCES categories (id) NOT NULL
+);
+
+CREATE TABLE post_tag
+(
+    post SERIAL REFERENCES posts (id),
+    tag  SERIAL REFERENCES tags (id)
+);
+
+CREATE TABLE metadata
+(
+    pid        SERIAL REFERENCES posts (id) NOT NULL,
+    meta_key   VARCHAR(50)                  NOT NULL,
+    meta_value TEXT                         NOT NULL,
+
+    CONSTRAINT meta_pk PRIMARY KEY (pid, meta_key)
+);

backend/server/src/modules/mod.rs

@@ -0,0 +1,84 @@
+pub mod blog;
+
+use std::env;
+use std::num::ParseIntError;
+
+use crate::{
+    constants::config::server::{default_value, var_name},
+    scheduler::{tasks::CronTask, Scheduler},
+};
+use macros::error_panic;
+
+use axum::Router;
+use tracing::{info, warn};
+
+// todo: merge `get_server_router` & `get_mount_point`, make Option
+pub trait Module {
+    fn get_server_router(&self) -> Router;
+
+    fn get_mount_point(&self) -> &'static str;
+
+    fn get_cron_tasks(&self) -> Vec<Box<dyn CronTask>>;
+}
+
+pub struct ModuleTree {
+    pub modules: Vec<Box<dyn Module>>,
+}
+
+impl ModuleTree {
+    pub fn new() -> Self {
+        ModuleTree { modules: vec![] }
+    }
+
+    pub fn add_module(&mut self, module: impl Module + 'static) -> &mut Self {
+        self.modules.push(Box::new(module));
+        self
+    }
+
+    pub async fn blocking_serve(&self) {
+        let scheduler = Scheduler::new();
+        let mut app = Router::new();
+
+        let port: u32 = match env::var(var_name::PORT) {
+            Ok(value) => value.parse().unwrap_or_else(|e: ParseIntError| {
+                warn!(
+                    "failed to parse `{}`, using default port: {}",
+                    var_name::PORT,
+                    e.to_string()
+                );
+                default_value::PORT
+            }),
+            Err(_) => default_value::PORT,
+        };
+
+        let listener = match tokio::net::TcpListener::bind(format!(
+            "{}:{}",
+            default_value::HOST,
+            port
+        ))
+        .await
+        {
+            Ok(listener) => {
+                info!("server started on {}:{}", default_value::HOST, port);
+                listener
+            }
+            Err(e) => {
+                error_panic!(
+                    "failed to start server on {}:{}: {}",
+                    default_value::HOST,
+                    port,
+                    e.to_string()
+                );
+            }
+        };
+
+        for module in &self.modules {
+            let _ = scheduler.insert_list(module.get_cron_tasks());
+            app = app.nest(module.get_mount_point(), module.get_server_router());
+        }
+
+        axum::serve(listener, app).await.unwrap_or_else(|e| {
+            error_panic!("failed to start axum: {}", e.to_string());
+        });
+    }
+}

backend/server/src/scheduler/mod.rs

@@ -0,0 +1,202 @@
+use std::{
+    collections::HashMap,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc, RwLock,
+    },
+    thread,
+};
+
+use crate::scheduler::{
+    scheduler_error::{
+        SchedulerError, SchedulerError::IdAlreadyRunning, SchedulerError::IdNotFound,
+    },
+    sleeper::SkippableSleeper,
+    tasks::CronTask,
+};
+
+use tracing::log::error;
+use uuid::Uuid;
+
+pub mod scheduler_error;
+mod sleeper;
+mod task_func;
+pub mod tasks;
+
+struct TaskStatus {
+    sleeper: Option<Arc<SkippableSleeper>>,
+    is_alive: AtomicBool,
+}
+
+#[derive(Default)]
+pub struct Scheduler {
+    tasks: Arc<RwLock<HashMap<Uuid, Arc<Box<dyn CronTask>>>>>,
+    running: Arc<RwLock<HashMap<Uuid, Arc<TaskStatus>>>>,
+}
+
+impl Scheduler {
+    /// Start all tasks in the scheduler
+    pub fn start(&self) -> Result<(), SchedulerError> {
+        for (k, _v) in self.tasks.read()?.iter() {
+            self.run_non_blocking(k)?
+        }
+        Ok(())
+    }
+
+    /// Terminate all tasks in the scheduler
+    pub fn halt() {}
+
+    fn run_task(
+        running: Arc<RwLock<HashMap<Uuid, Arc<TaskStatus>>>>,
+        id: Uuid,
+        task: Arc<Box<dyn CronTask>>,
+    ) -> Result<(), SchedulerError> {
+        if running.read()?.get(&id).is_some() {
+            return Err(IdAlreadyRunning);
+        } else {
+            running.write()?.insert(
+                id,
+                TaskStatus {
+                    sleeper: None,
+                    is_alive: AtomicBool::new(true),
+                }
+                .into(),
+            );
+        }
+        loop {
+            if let Some(next_execution) = task.get_next_execution() {
+                // guarantee is alive
+                let task_status = {
+                    let running_reading_guard = running.read()?;
+                    running_reading_guard.get(&id).cloned().clone()
+                };
+                if let Some(task_status) = task_status {
+                    if !&task_status.is_alive.load(Ordering::SeqCst) {
+                        {
+                            let mut running_lock_guard = running.write()?;
+                            running_lock_guard.remove(&id);
+                        }
+                        return Ok(());
+                    } else {
+                        let sleeper = Arc::from(SkippableSleeper::from(next_execution));
+                        {
+                            let mut running_lock_guard = running.write()?;
+                            running_lock_guard.insert(
+                                id,
+                                TaskStatus {
+                                    sleeper: Some(sleeper.clone()),
+                                    is_alive: AtomicBool::new(true),
+                                }
+                                .into(),
+                            );
+                        }
+                        sleeper.start();
+                        task.call();
+                    }
+                }
+            } else {
+                error!("unexpected error ");
+                break;
+            }
+        }
+        Ok(())
+    }
+
+    /// Run a task with `id`
+    pub fn run(&self, id: &Uuid) -> Result<(), SchedulerError> {
+        let id = id.to_owned();
+        if let Some(task) = self.tasks.read()?.get(&id) {
+            Self::run_task(self.running.clone(), id, task.clone())
+        } else {
+            Err(IdNotFound)
+        }
+    }
+
+    pub fn run_non_blocking(&self, id: &Uuid) -> Result<(), SchedulerError> {
+        let id = id.to_owned();
+        if let Some(task) = self.tasks.read()?.get(&id) {
+            let running_clone = self.running.clone();
+            let task_clone = task.clone();
+            thread::spawn(move || Self::run_task(running_clone, id, task_clone));
+            Ok(())
+        } else {
+            Err(IdNotFound)
+        }
+    }
+
+    fn get_running(&self, id: &Uuid) -> Option<Arc<TaskStatus>> {
+        let ret = self.running.read().unwrap().get(id).cloned();
+        ret
+    }
+
+    /// Stop a task with `id`
+    pub fn stop(&self, id: &Uuid) -> Result<(), SchedulerError> {
+        match self.get_running(id) {
+            None => Err(IdNotFound),
+            Some(status) => {
+                status.is_alive.store(false, Ordering::SeqCst);
+                if let Some(s) = &status.sleeper {
+                    s.skip();
+                } else {
+                    return Err(IdAlreadyRunning);
+                }
+                Ok(())
+            }
+        }
+    }
+
+    pub fn now(&self, id: &Uuid) -> Result<(), SchedulerError> {
+        match self.get_running(id) {
+            None => Err(IdNotFound),
+            Some(status) => {
+                if let Some(s) = &status.sleeper {
+                    s.skip()
+                } else {
+                    return Err(IdAlreadyRunning);
+                }
+                Ok(())
+            }
+        }
+    }
+
+    pub fn insert(&self, task: Box<dyn CronTask>) -> Result<Uuid, SchedulerError> {
+        let id = Uuid::new_v4();
+        self.tasks.write()?.insert(id, Arc::new(task));
+        Ok(id)
+    }
+
+    pub fn insert_list(&self, tasks: Vec<Box<dyn CronTask>>) -> Result<Vec<Uuid>, SchedulerError> {
+        tasks.into_iter().map(|t| self.insert(t)).collect()
+    }
+
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::scheduler::tasks::basic::BasicTask;
+    use crate::scheduler::Scheduler;
+    use std::error::Error;
+    use std::thread;
+    use std::time::Duration;
+
+    #[test]
+    fn test_run() -> Result<(), Box<dyn Error>> {
+        let scheduler = Scheduler::default();
+        let task = BasicTask::new(|| println!("test print"), "* * * * * *")?;
+        let id = scheduler.insert(Box::new(task))?;
+        for i in 1..=2 {
+            println!("Loop {} start", i);
+            println!("Run {}", i);
+            scheduler.run_non_blocking(&id)?;
+            thread::sleep(Duration::from_secs(4));
+            scheduler.stop(&id)?;
+            println!("Stop {}", i);
+            thread::sleep(Duration::from_secs(2));
+            println!("Loop {} finished", i);
+        }
+        Ok(())
+    }
+}

backend/server/src/scheduler/scheduler_error.rs

@@ -0,0 +1,48 @@
+use std::{
+    error::Error,
+    fmt::{Debug, Display, Formatter},
+    sync::PoisonError,
+};
+
+use crate::scheduler::scheduler_error::SchedulerError::MutexPoison;
+
+// todo: refactor with thiserror
+pub enum SchedulerError {
+    IdNotFound,
+    IdAlreadyRunning,
+    MutexPoison(String),
+}
+
+impl<T> From<PoisonError<T>> for SchedulerError {
+    fn from(value: PoisonError<T>) -> Self {
+        MutexPoison(value.to_string())
+    }
+}
+
+impl Debug for SchedulerError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl Display for SchedulerError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                SchedulerError::IdNotFound => {
+                    "SchedulerError::IdNotFound".to_string()
+                }
+                SchedulerError::IdAlreadyRunning => {
+                    "SchedulerError::IdAlreadyRunning".to_string()
+                }
+                MutexPoison(str) => {
+                    format!("SchedulerError::MutexPoison: {}", str)
+                }
+            }
+        )
+    }
+}
+
+impl Error for SchedulerError {}

backend/server/src/scheduler/sleeper.rs

@@ -0,0 +1,80 @@
+use std::{
+    sync::{Arc, Condvar, Mutex},
+    thread,
+    time::Duration,
+};
+
+use chrono::{DateTime, Utc};
+
+#[derive(Clone, Debug, Default)]
+pub struct SkippableSleeper {
+    pub duration: Duration,
+    state: Arc<(Mutex<bool>, Condvar)>,
+}
+
+impl SkippableSleeper {
+    pub fn new(duration: Duration) -> Self {
+        SkippableSleeper {
+            duration,
+            state: Arc::new((Mutex::new(false), Condvar::new())),
+        }
+    }
+
+    // Blocks until the duration has passed or skip() is called
+    pub fn start(&self) {
+        let (lock, cvar) = &*self.state;
+        let mut received = lock.lock().unwrap();
+        let state_clone = Arc::clone(&self.state);
+        let duration_clone = self.duration;
+        thread::spawn(move || {
+            thread::sleep(duration_clone);
+            let (lock, cvar) = &*state_clone;
+            let mut received = lock.lock().unwrap();
+            *received = true;
+            cvar.notify_one();
+        });
+        while !*received {
+            received = cvar.wait(received).unwrap();
+        }
+    }
+
+    // Skip the blocking delay
+    pub fn skip(&self) {
+        let (lock, cvar) = &*self.state;
+        let mut received = lock.lock().unwrap();
+        *received = true;
+        cvar.notify_one();
+    }
+}
+
+impl From<DateTime<Utc>> for SkippableSleeper {
+    fn from(value: DateTime<Utc>) -> Self {
+        let from_utc_timestamp = value.timestamp() as u64;
+        let curr_utc_timestamp = Utc::now().timestamp() as u64;
+        SkippableSleeper::new(Duration::from_secs(from_utc_timestamp - curr_utc_timestamp))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::scheduler::sleeper::SkippableSleeper;
+    use std::thread;
+    use std::time::Duration;
+
+    #[test]
+    fn usage() {
+        let sleeper = SkippableSleeper::new(Duration::new(10, 0));
+        thread::spawn({
+            let sleeper = sleeper.clone();
+            move || {
+                println!("Sleeping...");
+                sleeper.start();
+                println!("Woke up!");
+            }
+        });
+        println!("Start Sleeping...");
+        thread::sleep(Duration::from_secs(4));
+        println!("Skipping sleep...");
+        sleeper.skip();
+    }
+}

backend/server/src/scheduler/task_func.rs

@@ -0,0 +1,3 @@
+pub trait TaskFunc: Fn() + Send + Sync + 'static {}
+
+impl<T> TaskFunc for T where T: Fn() + Send + Sync + Clone + 'static {}

backend/server/src/scheduler/tasks/basic.rs

@@ -0,0 +1,38 @@
+use std::error::Error;
+use std::str::FromStr;
+
+use crate::scheduler::{task_func::TaskFunc, tasks::CronTask};
+
+use chrono::{DateTime, Utc};
+use cron::Schedule;
+
+pub struct BasicTask {
+    schedule: Schedule,
+    func: Box<dyn TaskFunc>,
+}
+
+impl BasicTask {
+    pub fn new<F>(func: F, cron_expr: &str) -> Result<Self, Box<dyn Error>>
+    where
+        F: TaskFunc,
+    {
+        Ok(BasicTask {
+            schedule: Schedule::from_str(cron_expr)?,
+            func: Box::new(func),
+        })
+    }
+
+    pub fn to_task(self) -> Box<dyn CronTask> {
+        Box::new(self)
+    }
+}
+
+impl CronTask for BasicTask {
+    fn get_next_execution(&self) -> Option<DateTime<Utc>> {
+        self.schedule.upcoming(Utc).next()
+    }
+
+    fn call(&self) {
+        (self.func)()
+    }
+}

backend/server/src/scheduler/tasks/mod.rs

@@ -0,0 +1,8 @@
+use chrono::{DateTime, Utc};
+
+pub mod basic;
+
+pub trait CronTask: Send + Sync {
+    fn get_next_execution(&self) -> Option<DateTime<Utc>>;
+    fn call(&self);
+}

backend/server/src/utils/git.rs

@@ -0,0 +1,166 @@
+/// git merge
+/// based on https://github.com/rust-lang/git2-rs/blob/master/examples/pull.rs
+/// https://github.com/rust-lang/git2-rs/commit/f3b87baed1e33d6c2d94fe1fa6aa6503a071d837
+///
+use git2::{
+    build, AnnotatedCommit, AutotagOption, Delta, FetchOptions, Reference, Remote, Repository,
+};
+use std::path::PathBuf;
+use tracing::{error, warn};
+
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct FileDelta {
+    pub old_path: Option<PathBuf>,
+    pub new_path: Option<PathBuf>,
+    pub status: Delta,
+}
+
+#[allow(dead_code)]
+fn do_fetch<'a>(
+    repo: &'a Repository,
+    refs: &[&str],
+    remote: &'a mut Remote,
+) -> Result<AnnotatedCommit<'a>, git2::Error> {
+    let mut fetch_option = FetchOptions::new();
+
+    fetch_option.download_tags(AutotagOption::All);
+    remote.fetch(refs, Some(&mut fetch_option), None)?;
+
+    let fetch_head = repo.find_reference("FETCH_HEAD")?;
+    repo.reference_to_annotated_commit(&fetch_head)
+}
+
+#[allow(dead_code)]
+fn fast_forward(
+    repo: &Repository,
+    lb: &mut Reference,
+    rc: &AnnotatedCommit,
+) -> Result<(), git2::Error> {
+    let name = match lb.name() {
+        Some(s) => s.to_string(),
+        None => String::from_utf8_lossy(lb.name_bytes()).to_string(),
+    };
+    let msg = format!("fast-forward({}) -> {}", name, rc.id());
+    // println!("{}", msg);
+    lb.set_target(rc.id(), &msg)?;
+    repo.set_head(&name)?;
+    repo.checkout_head(Some(build::CheckoutBuilder::default().force()))?;
+    Ok(())
+}
+
+#[allow(dead_code)]
+fn normal_merge(
+    repo: &Repository,
+    local: &AnnotatedCommit,
+    remote: &AnnotatedCommit,
+) -> Result<(), git2::Error> {
+    let local_tree = repo.find_commit(local.id())?.tree()?;
+    let remote_tree = repo.find_commit(remote.id())?.tree()?;
+    let ancestor = repo
+        .find_commit(repo.merge_base(local.id(), remote.id())?)?
+        .tree()?;
+    let mut idx = repo.merge_trees(&ancestor, &local_tree, &remote_tree, None)?;
+
+    if idx.has_conflicts() {
+        warn!("merge conflicts detected");
+        repo.checkout_index(Some(&mut idx), None)?;
+        return Ok(());
+    }
+    let result_tree = repo.find_tree(idx.write_tree_to(repo)?)?;
+
+    let msg = format!("merge({}) -> {}", remote.id(), local.id());
+    let sig = repo.signature()?;
+    let local_commit = repo.find_commit(local.id())?;
+    let remote_commit = repo.find_commit(remote.id())?;
+
+    let _merge_commit = repo.commit(
+        Some("HEAD"),
+        &sig,
+        &sig,
+        &msg,
+        &result_tree,
+        &[&local_commit, &remote_commit],
+    )?;
+    repo.checkout_head(None)?;
+    Ok(())
+}
+
+#[allow(dead_code)]
+fn do_merge<'a>(
+    repo: &'a Repository,
+    remote_branch: &str,
+    fetch_commit: AnnotatedCommit<'a>,
+) -> Result<Vec<FileDelta>, git2::Error> {
+    let analysis = repo.merge_analysis(&[&fetch_commit])?;
+    let head_commit = repo.reference_to_annotated_commit(&repo.head()?)?;
+
+    if analysis.0.is_fast_forward() {
+        let ref_name = format!("refs/heads/{}", remote_branch);
+        match repo.find_reference(&ref_name) {
+            Ok(mut r) => {
+                fast_forward(repo, &mut r, &fetch_commit)?;
+            }
+            Err(_) => {
+                repo.reference(
+                    &ref_name,
+                    fetch_commit.id(),
+                    true,
+                    &format!("({}) -> {}", remote_branch, fetch_commit.id()),
+                )?;
+                repo.set_head(&ref_name)?;
+                repo.checkout_head(Some(
+                    build::CheckoutBuilder::default()
+                        .allow_conflicts(true)
+                        .conflict_style_merge(true)
+                        .force(),
+                ))?;
+            }
+        };
+    } else if analysis.0.is_normal() {
+        normal_merge(repo, &head_commit, &fetch_commit)?;
+    }
+    calculate_diff(repo, &head_commit, &fetch_commit)
+}
+
+#[allow(dead_code)]
+fn calculate_diff(
+    repo: &Repository,
+    local: &AnnotatedCommit,
+    remote: &AnnotatedCommit,
+) -> Result<Vec<FileDelta>, git2::Error> {
+    let local_tree = repo.find_commit(local.id())?.tree()?;
+    let remote_tree = repo.find_commit(remote.id())?.tree()?;
+    let diff = repo.diff_tree_to_tree(Some(&local_tree), Some(&remote_tree), None)?;
+
+    let mut updated_files: Vec<FileDelta> = Vec::new();
+
+    if let Err(e) = diff.foreach(
+        &mut |d, _| {
+            updated_files.push(FileDelta {
+                old_path: d.old_file().path().map(PathBuf::from),
+                new_path: d.new_file().path().map(PathBuf::from),
+                status: d.status(),
+            });
+            true
+        },
+        None,
+        None,
+        None,
+    ) {
+        error!("error at calculating diff: {:?}", e);
+    }
+
+    Ok(updated_files.into_iter().collect())
+}
+
+#[allow(dead_code)]
+pub fn sync(
+    remote_name: &str,
+    remote_branch: &str,
+    repo: &Repository,
+) -> Result<Vec<FileDelta>, git2::Error> {
+    let mut remote = repo.find_remote(remote_name)?;
+    let fetch_commit = do_fetch(repo, &[remote_branch], &mut remote)?;
+    do_merge(repo, remote_branch, fetch_commit)
+}

backend/server/src/utils/mod.rs

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

frontend/.dockerignore

@@ -0,0 +1,10 @@
+/node_modules
+
+/.next
+/out
+/build
+
+.DS_Store
+*.pem
+
+.env*.local

frontend/.eslintignore

@@ -1,38 +0,0 @@
-**/*.log
-**/.DS_Store
-*.
-.vscode/settings.json
-.history
-.yarn
-bazel-*
-bazel-bin
-bazel-out
-bazel-qwik
-bazel-testlogs
-dist
-dist-dev
-lib
-lib-types
-etc
-external
-node_modules
-temp
-tsc-out
-tsdoc-metadata.json
-target
-output
-rollup.config.js
-build
-.cache
-.vscode
-.rollup.cache
-dist
-tsconfig.tsbuildinfo
-vite.config.ts
-*.spec.tsx
-*.spec.ts
-.netlify
-pnpm-lock.yaml
-package-lock.json
-yarn.lock
-server

frontend/.eslintrc.cjs

@@ -1,42 +0,0 @@
-module.exports = {
-  root: true,
-  env: {
-    browser: true,
-    es2021: true,
-    node: true,
-  },
-  extends: [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "plugin:qwik/recommended",
-  ],
-  parser: "@typescript-eslint/parser",
-  parserOptions: {
-    tsconfigRootDir: __dirname,
-    project: ["./tsconfig.json"],
-    ecmaVersion: 2021,
-    sourceType: "module",
-    ecmaFeatures: {
-      jsx: true,
-    },
-  },
-  plugins: ["@typescript-eslint"],
-  rules: {
-    "@typescript-eslint/no-explicit-any": "off",
-    "@typescript-eslint/explicit-module-boundary-types": "off",
-    "@typescript-eslint/no-inferrable-types": "off",
-    "@typescript-eslint/no-non-null-assertion": "off",
-    "@typescript-eslint/no-empty-interface": "off",
-    "@typescript-eslint/no-namespace": "off",
-    "@typescript-eslint/no-empty-function": "off",
-    "@typescript-eslint/no-this-alias": "off",
-    "@typescript-eslint/ban-types": "off",
-    "@typescript-eslint/ban-ts-comment": "off",
-    "prefer-spread": "off",
-    "no-case-declarations": "off",
-    "no-console": "off",
-    "@typescript-eslint/no-unused-vars": ["error"],
-    "@typescript-eslint/consistent-type-imports": "warn",
-    "@typescript-eslint/no-unnecessary-condition": "warn",
-  },
-};

frontend/.eslintrc.json

@@ -0,0 +1,3 @@
+{
+  "extends": "next/core-web-vitals"
+}

frontend/.gitignore

@@ -1,42 +1,43 @@
-# Build
-/dist
-/lib
-/lib-types
-/server
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 
-# Development
-node_modules
-.env
-*.local
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+.yarn/install-state.gz
 
-# Cache
-.cache
-.mf
-.rollup.cache
-tsconfig.tsbuildinfo
+# testing
+/coverage
 
-# Logs
-logs
-*.log
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
-pnpm-debug.log*
-lerna-debug.log*
 
-# Editor
-.vscode/*
-!.vscode/launch.json
-!.vscode/*.code-snippets
+# local env files
+.env*.local
 
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
+
+# bun
+bun.lockb
+
+# ide related
 .idea
-.DS_Store
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw?
-
-# Yarn
-.yarn/*
-!.yarn/releases
+/package-lock.json

frontend/.prettierignore

@@ -1,37 +0,0 @@
-**/*.log
-**/.DS_Store
-*.
-.vscode/settings.json
-.history
-.yarn
-bazel-*
-bazel-bin
-bazel-out
-bazel-qwik
-bazel-testlogs
-dist
-dist-dev
-lib
-lib-types
-etc
-external
-node_modules
-temp
-tsc-out
-tsdoc-metadata.json
-target
-output
-rollup.config.js
-build
-.cache
-.vscode
-.rollup.cache
-tsconfig.tsbuildinfo
-vite.config.ts
-*.spec.tsx
-*.spec.ts
-.netlify
-pnpm-lock.yaml
-package-lock.json
-yarn.lock
-server

frontend/README.md

@@ -1,65 +0,0 @@
-# Qwik City App ⚡️
-
-- [Qwik Docs](https://qwik.dev/)
-- [Discord](https://qwik.dev/chat)
-- [Qwik GitHub](https://github.com/QwikDev/qwik)
-- [@QwikDev](https://twitter.com/QwikDev)
-- [Vite](https://vitejs.dev/)
-
----
-
-## Project Structure
-
-This project is using Qwik with [QwikCity](https://qwik.dev/qwikcity/overview/). QwikCity is just an extra set of tools on top of Qwik to make it easier to build a full site, including directory-based routing, layouts, and more.
-
-Inside your project, you'll see the following directory structure:
-
-```
-├── public/
-│   └── ...
-└── src/
-    ├── components/
-    │   └── ...
-    └── routes/
-        └── ...
-```
-
-- `src/routes`: Provides the directory-based routing, which can include a hierarchy of `layout.tsx` layout files, and an `index.tsx` file as the page. Additionally, `index.ts` files are endpoints. Please see the [routing docs](https://qwik.dev/qwikcity/routing/overview/) for more info.
-
-- `src/components`: Recommended directory for components.
-
-- `public`: Any static assets, like images, can be placed in the public directory. Please see the [Vite public directory](https://vitejs.dev/guide/assets.html#the-public-directory) for more info.
-
-## Add Integrations and deployment
-
-Use the `npm run qwik add` command to add additional integrations. Some examples of integrations includes: Cloudflare, Netlify or Express Server, and the [Static Site Generator (SSG)](https://qwik.dev/qwikcity/guides/static-site-generation/).
-
-```shell
-npm run qwik add # or `yarn qwik add`
-```
-
-## Development
-
-Development mode uses [Vite's development server](https://vitejs.dev/). The `dev` command will server-side render (SSR) the output during development.
-
-```shell
-npm start # or `yarn start`
-```
-
-> Note: during dev mode, Vite may request a significant number of `.js` files. This does not represent a Qwik production build.
-
-## Preview
-
-The preview command will create a production build of the client modules, a production build of `src/entry.preview.tsx`, and run a local server. The preview server is only for convenience to preview a production build locally and should not be used as a production server.
-
-```shell
-npm run preview # or `yarn preview`
-```
-
-## Production
-
-The production build will generate client and server modules by running both client and server build commands. The build command will use Typescript to run a type check on the source code.
-
-```shell
-npm run build # or `yarn build`
-```

frontend/app/(pages)/about/layout.tsx

@@ -0,0 +1,21 @@
+import React from 'react';
+import { Metadata } from 'next';
+import { SITE_CONFIG } from '@/src/constants';
+
+export const metadata: Metadata = {
+    title: `About - ${ SITE_CONFIG.name }`
+};
+
+function Layout({
+    children
+}: {
+    children: React.ReactNode;
+}) {
+    return (
+        <div className={ 'flex p-7' }>
+            { children }
+        </div>
+    );
+}
+
+export default Layout;

frontend/app/(pages)/about/me/page.tsx

@@ -0,0 +1,15 @@
+import React from 'react';
+import MarkdownRenderer from '@/app/(pages)/public/MarkdownRenderer';
+import { fetchText } from '@/app/fetch';
+
+const Me = async () => {
+    return (
+        <div className={ 'p-5' }>
+            <MarkdownRenderer>
+                { await fetchText('https://raw.githubusercontent.com/lumither/blog-posts/master/about/me.md') }
+            </MarkdownRenderer>
+        </div>
+    );
+};
+
+export default Me;

frontend/app/(pages)/about/page.tsx

@@ -0,0 +1,58 @@
+import { Card } from '@nextui-org/react';
+import React from 'react';
+import { CardBody } from '@nextui-org/card';
+import Link from 'next/link';
+
+const About = () => {
+    return (
+        <div className={ `flex flex-col w-full justify-center align-middle h-dvh` }>
+            <div className={ 'md:relative md:h-[130px] mb-4 md:mb-0' }>
+                <div className={ 'md:relative md:left-[20%] flex flex-col w-fit' }>
+                    <p className={ 'text-pretty text-3xl' }>{ '讷，远道而来的' }<span
+                        className={ 'break-keep underline decoration-sky-400 dark:decoration-sky-700 decoration-4 underline-offset-0' }>旅人</span>
+                    </p>
+                    <p className={ 'text-pretty md:text-2xl mt-1 md:ml-4' }>{ '愿意坐下来听个故事吗...' }</p>
+                    <p className={ 'hidden md:block text-lg md:ml-8' }>{ '一个关于一位' }<span
+                        className={ 'text-gray-700 dark:text-gray-400 text-sm transition-colors' }>{ '█' }</span>{ '追寻' }<span
+                        className={ 'text-gray-700 dark:text-gray-400 text-sm transition-colors' }>{ '█' }</span>{ '，探索' }<span
+                        className={ 'text-gray-700 dark:text-gray-400 text-sm transition-colors' }>{ '█' }</span>{ '的故事' }
+                    </p>
+                </div>
+            </div>
+            <div className={ `flex justify-center w-full h-[60%] md:h-[40%]` }>
+                <div
+                    className={ `flex flex-col md:flex-row w-full md:w-[85%] lg:w-[90%] xl:w-[85%] p-4 gap-x-7 gap-y-5` }>
+                    <Card
+                        isHoverable
+                        className={ 'w-full h-[45%] md:h-full' }
+                        as={ Link }
+                        href={ '/about/me' }
+                        isPressable
+                    >
+                        <CardBody>
+                            <div className={ 'h-full flex flex-col justify-center' }>
+                                <p className={ 'text-center text-3xl h-fit' }>关于我</p>
+                            </div>
+                        </CardBody>
+                    </Card>
+                    <Card
+                        isHoverable
+                        className={ 'w-full h-[45%] md:h-full' }
+                        as={ Link }
+                        href={ '/about/website' }
+                        isPressable
+                    >
+                        <CardBody>
+                            <div className={ 'h-full flex flex-col justify-center' }>
+                                <p className={ 'text-center text-3xl h-fit' }>关于这个网站</p>
+                            </div>
+                        </CardBody>
+                    </Card>
+                </div>
+            </div>
+            <p className={ 'text-center' }>*目前还没想到如何设计这一页，先摸鱼会（笑）</p>
+        </div>
+    );
+};
+
+export default About;

frontend/app/(pages)/about/website/page.tsx

@@ -0,0 +1,14 @@
+import React from 'react';
+import MarkdownRenderer from '@/app/(pages)/public/MarkdownRenderer';
+import { fetchText } from '@/app/fetch';
+
+const Website = async () => {
+    return (
+        <div className={ 'p-5' }>
+            <MarkdownRenderer>
+                { await fetchText('https://raw.githubusercontent.com/lumither/blog-posts/master/about/website.md') }
+            </MarkdownRenderer>
+        </div>
+    );
+};
+export default Website;

frontend/app/(pages)/blog/BlogPostCard.tsx

@@ -0,0 +1,92 @@
+import React from 'react';
+import { Card, CardBody, CardFooter } from '@nextui-org/card';
+import { Chip } from '@nextui-org/react';
+import Image from 'next/image';
+import Link from 'next/link';
+import { MdCalendarMonth, MdNorthEast } from 'react-icons/md';
+
+type Props = {
+    post: JSON
+}
+
+function BlogPostCard({ post }: Props) {
+    let title = (post as any)['title'];
+    let sub_title = (post as any)['sub_title'];
+    // let summary = (post as any)['summary'];
+    let category = (post as any)['category'];
+    let tags = (post as any)['tags'];
+    // let last_update = new Date((post as any)['last_update']);
+    let first_update = new Date((post as any)['first_update']);
+    let post_id = (post as any)['post_id'];
+    let header_img = ((post as any)['header_img'] as string | null);
+
+    return (
+
+        <div className={ `w-full` }>
+            <Card as={ Link } href={ `/blog/post/${ post_id }` }
+                  className={ `group` }
+                  isPressable
+                  isHoverable
+            >
+
+                { header_img && <div className={ `w-full overflow h-80 relative` }>
+                    <Image
+                        alt={ 'cover picture' }
+                        src={ header_img }
+                        className={ `w-full object-cover rounded-b-none z-10` }
+                        loading={ 'eager' }
+                        fill
+                    ></Image>
+                    <Image
+                        alt={ 'cover picture shadow' }
+                        src={ header_img }
+                        loading={ 'eager' }
+                        className={ `w-full object-cover rounded-b-none scale-y-110 blur-2xl` }
+                        fill
+                    ></Image>
+                </div> }
+
+                <CardBody className={ `overflow-visible` }>
+                    <div className={ `flex flex-row justify-between` }>
+                        <div className={ `mx-2 ${ header_img ? '-mt-6' : 'mt-2' }` }>
+                            <Chip className={ `mb-2 z-30 text-lg` } radius={ `sm` } size={ 'lg' } color={ `secondary` }
+                                  variant={ `solid` }>{ category }</Chip>
+                            <p className={ `text-4xl font-bold` }> { title }</p>
+                            <p className={ `text-xl` }> { sub_title }</p>
+                        </div>
+                        <MdNorthEast className={ `mt-1 mr-2` } size={ `40px` } />
+                    </div>
+                </CardBody>
+
+                <CardFooter className={ 'pt-0' }>
+                    <div className={ `flex flex-row flex-wrap justify-between w-full` }>
+                        <div>
+                            <ul className={ `flex flex-row flex-wrap` }>
+                                {
+                                    tags.map((tag: string, key: any) => (
+                                        <li key={ key } className={ `mx-1 mb-1` }>
+                                            <Chip>{ tag }</Chip>
+                                        </li>
+                                    ))
+                                }
+                            </ul>
+                        </div>
+                        <div className={ `flex flex-row place-content-end mb-1 items-center mx-1` }>
+                            <MdCalendarMonth />
+                            <p className={ `text-zinc-500 dark:text-zinc-400 ml-1` }>
+                                { first_update.toLocaleString('default', {
+                                    month: `long`,
+                                    day: `numeric`,
+                                    year: `numeric`
+                                }) }
+                            </p>
+                        </div>
+                    </div>
+                </CardFooter>
+            </Card>
+        </div>
+    );
+
+}
+
+export default BlogPostCard;

frontend/app/(pages)/blog/Error.tsx

@@ -0,0 +1 @@
+// todo: create component

frontend/app/(pages)/blog/Pagination.tsx

@@ -0,0 +1,37 @@
+'use client';
+
+import React from 'react';
+import { Pagination as NextUIPagination } from '@nextui-org/react';
+import { useRouter, useSearchParams } from 'next/navigation';
+import { useScreenSizeTrigger } from '@/app/(pages)/public/screenSizeTrigger';
+
+const Pagination = ({ total }: {
+    total: number,
+}) => {
+    const parsePage = Number(useSearchParams().get('page'));
+    const currPage = parsePage > 0 ? parsePage : 1;
+
+    const router = useRouter();
+
+    const isMobile = useScreenSizeTrigger('md');
+
+    return (
+        <div className={ 'w-full p-4 pt-6 flex justify-center' }>
+            <NextUIPagination
+                initialPage={ currPage }
+                total={ total }
+                siblings={ isMobile ? 0 : 1 }
+                size={ isMobile ? 'sm' : 'md' }
+                showControls
+                showShadow
+                color={ 'default' }
+                variant={ 'light' }
+                onChange={ (page) => {
+                    router.push(`?page=${ page }`, { scroll: false });
+                } }
+            />
+        </div>
+
+    );
+};
+export default Pagination;

frontend/app/(pages)/blog/PostList.tsx

@@ -0,0 +1,43 @@
+'use server';
+
+import React from 'react';
+import { fetchNocturneApi } from '@/app/(pages)/blog/api';
+import BlogPostCard from '@/app/(pages)/blog/BlogPostCard';
+import { Card, CardBody } from '@nextui-org/card';
+
+import * as motion from 'motion/react-client';
+
+const PostList = async ({ page }: { page: number }) => {
+    try {
+        const res = await fetchNocturneApi(`/blog/get_post_list?page=${ page }`);
+        const posts = await res.json();
+        return (
+            // blog list
+            <div className={ 'w-full' }>
+                <ul className={ 'flex flex-col items-center w-full space-y-7' }>
+                    { posts.map((post: JSON, key: number) => (
+                        <li key={ key } className={ 'w-full' }>
+                            <motion.div
+                                initial={ { y: 20, opacity: 0 } }
+                                animate={ { y: 0, opacity: 1 } }
+                                transition={ { ease: 'easeInOut', duration: 0.5, delay: key * .2 + .25 } }
+                            >
+                                <BlogPostCard post={ post } />
+                            </motion.div>
+                        </li>)
+                    ) }
+                </ul>
+
+            </div>
+        );
+    } catch (e: any) {
+        return (
+            // todo:  use Error.tsx
+            <Card className={ `w-full` }>
+                <CardBody>
+                    Fatal: { e.toString() }
+                </CardBody>
+            </Card>);
+    }
+};
+export default PostList;

frontend/app/(pages)/blog/api.ts

@@ -0,0 +1,21 @@
+const LOCAL_ENDPOINT = process.env.API_LOCAL_URL;
+const REMOTE_ENDPOINT = process.env.API_REMOTE_URL;
+
+const NOCTURNE_ENDPOINT = ((isServerSide = true) => {
+    if (process.env.NODE_ENV === 'production') {
+        if (isServerSide) {
+            return LOCAL_ENDPOINT;
+        } else {
+            return REMOTE_ENDPOINT;
+        }
+    } else {
+        return LOCAL_ENDPOINT;
+    }
+});
+
+export async function fetchNocturneApi(path: string, isServerSideRequest = true) {
+    return await fetch(`${ NOCTURNE_ENDPOINT(isServerSideRequest) }${ path }`, {
+        cache: 'no-cache'
+    });
+}
+

frontend/app/(pages)/blog/layout.tsx

@@ -0,0 +1,23 @@
+import React from 'react';
+import { Metadata } from 'next';
+import { SITE_CONFIG } from '@/src/constants';
+
+export const metadata: Metadata = {
+    title: `Blog - ${ SITE_CONFIG.name }`
+};
+
+function Layout({
+    children
+}: {
+    children: React.ReactNode;
+}) {
+    return (
+        <div className={ 'flex flex-auto p-7 pl-2 lg:pl-7 w-full justify-center' }>
+            <main className={ 'w-full' }>
+                { children }
+            </main>
+        </div>
+    );
+}
+
+export default Layout;

frontend/app/(pages)/blog/page.tsx

@@ -0,0 +1,24 @@
+import PostList from '@/app/(pages)/blog/PostList';
+import Pagination from '@/app/(pages)/blog/Pagination';
+import { fetchNocturneApi } from '@/app/(pages)/blog/api';
+
+async function Blog({
+    searchParams
+}: {
+    searchParams: Promise<{ [key: string]: string | string[] | undefined }>
+}) {
+
+    const parsePage = Number((await searchParams)?.page);
+    const currPage = parsePage > 0 ? parsePage : 1;
+    const ret = await fetchNocturneApi(`/blog/get_page_count`);
+    const pageCount = (await ret.json() as any)['res'] as number;
+
+    return (
+        <div className={ 'w-full min-w-full space-y-4' }>
+            <PostList page={ currPage } />
+            <Pagination total={ pageCount } />
+        </div>
+    );
+}
+
+export default Blog;

frontend/app/(pages)/blog/post/[id]/ButtonGoBack.tsx

@@ -0,0 +1,21 @@
+'use client';
+
+import React from 'react';
+import { useRouter } from 'next/navigation';
+import { Button } from '@nextui-org/react';
+import { IoArrowBackOutline } from 'react-icons/io5';
+
+const ButtonGoBack = () => {
+    const router = useRouter();
+
+    return (
+        <Button
+            startContent={ <IoArrowBackOutline /> }
+            variant={ 'light' }
+            onClick={ () => router.back() }
+        >
+            { 'Back' }
+        </Button>
+    );
+};
+export default ButtonGoBack;

frontend/app/(pages)/blog/post/[id]/Footer.tsx

@@ -0,0 +1,104 @@
+import React from 'react';
+import MinifyPostCard from '@/app/(pages)/blog/post/[id]/MinifyPostCard';
+import Link from 'next/link';
+import { FaCreativeCommons } from 'react-icons/fa6';
+
+type Props = {
+    // post: any
+    post_id: string;
+    adjacent_posts: any
+    perm_link: string | undefined;
+    author: string | undefined;
+    author_link: string | undefined;
+    first_update: string;
+    last_update: string | undefined;
+    cc: string | undefined;
+    title: string;
+}
+
+const Footer = (props: Props) => {
+    const { adjacent_posts, perm_link, post_id, first_update, last_update, title } = props;
+
+    const prev_post = adjacent_posts.prev;
+    const next_post = adjacent_posts.next;
+    const link = perm_link ?? `https://lumither.com/blog/post/${ post_id }`;
+    const author = props.author ?? 'Tao';
+    const author_link = props.author_link ?? '/about/me';
+    const post_date = new Date(first_update);
+    const update_date: Date | undefined = last_update ? new Date(last_update) : undefined;
+    const cc = props.cc ?? 'by-nc-sa';
+
+
+    return (
+        <div className={ `w-full` }>
+
+            <div className={ 'flex transition bg-zinc-300/80 dark:bg-gray-600/25' }>
+                <div className={ `p-8 w-full overflow-hidden` }>
+                    <div className={ 'relative' }>
+                        <FaCreativeCommons
+                            size={ '160px' }
+                            className={ 'absolute right-0 top-0 -mt-[4.8rem] -mr-16 opacity-30 brightness-50  ' }
+                        />
+                    </div>
+
+                    <div className={ 'flex flex-col space-y-4 relative' }>
+                        <div className={ 'z-[2]' }>
+                            <p className={ 'text-xl font-bold' }>{ title }</p>
+                            <Link href={ link }>
+                                <p className={ 'text-sm underline decoration-indigo-500 dark:decoration-sky-500' }>{ link }</p>
+                            </Link>
+                        </div>
+                        <div className={ 'z-[2] flex flex-row flex-wrap gap-x-7 gap-y-2' }>
+                            <div>
+                                <p className={ 'text-lg font-bold' }>Author</p>
+                                <Link href={ author_link }>
+                                    <p className={ 'underline decoration-indigo-500 dark:decoration-sky-500' }>{ author }</p>
+                                </Link>
+                            </div>
+                            <div>
+                                <p className={ 'text-lg font-bold' }>Posted on</p>
+                                <p>{ post_date.toLocaleString('default', {
+                                    month: `long`,
+                                    day: `numeric`,
+                                    year: `numeric`
+                                }) }</p>
+                            </div>
+                            { update_date &&
+                                <div>
+                                    <p className={ 'text-lg font-bold' }>Updated on</p>
+                                    <p>{ update_date.toLocaleString('default', {
+                                        month: `long`,
+                                        day: `numeric`,
+                                        year: `numeric`
+                                    }) }</p>
+                                </div>
+                            }
+                            <div>
+                                <p className={ 'text-lg font-bold' }>Published under</p>
+                                <Link href={ `https://creativecommons.org/licenses/${ cc }/4.0/` }>
+                                    <p className={ 'underline decoration-indigo-500 dark:decoration-sky-500' }>{ `CC ${ cc.toUpperCase() } 4.0` }</p>
+                                </Link>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <div className={ `flex justify-center` }>
+                <div className={ `w-full shadow-2xl ` }>
+                    <div className={ `flex flex-col md:flex-row w-full` }>
+                        {
+                            next_post &&
+                            <MinifyPostCard post={ next_post } desc={ 'prev' }></MinifyPostCard>
+                        }
+                        {
+                            prev_post &&
+                            <MinifyPostCard post={ prev_post } desc={ 'next' }></MinifyPostCard>
+                        }
+                    </div>
+                </div>
+            </div>
+        </div>
+    );
+};
+export default Footer;

frontend/app/(pages)/blog/post/[id]/Headers.tsx

@@ -0,0 +1,80 @@
+import React from 'react';
+import Image from 'next/image';
+import { Chip } from '@nextui-org/react';
+import { MdCalendarMonth } from 'react-icons/md';
+
+// type Props = {
+//     post: any
+// };
+
+type Props = {
+    title: string;
+    subtitle: string;
+    summary: string | undefined;
+    category: string;
+    tags: string[];
+    first_update: string;
+    header_img: string | undefined;
+}
+
+
+const Headers = (post: Props) => {
+
+    return (
+        <>
+            { post.header_img && <div className={ `w-full overflow h-96 relative` }>
+                <Image
+                    alt={ 'cover picture' }
+                    src={ post.header_img }
+                    className={ `w-full object-cover rounded-b-none z-[5]` }
+                    fill
+                ></Image>
+                <Image
+                    alt={ 'cover picture' }
+                    src={ post.header_img }
+                    className={ `w-full relative scale-110 blur-3xl object-cover rounded-b-none` }
+                    fill
+                ></Image>
+            </div> }
+
+            <div
+                className={ post.header_img ?
+                    'mx-8 -mt-16 backdrop-blur transition bg-zinc-300/80 dark:bg-gray-600/25 rounded-2xl z-30'
+                    : 'mx-6 mt-6'
+                }>
+                <div className={ post.header_img ? `p-4` : 'p-4 pt-2' }>
+                    <Chip className={ `mb-2` } radius={ `sm` } color={ `secondary` }
+                          variant={ `solid` }>{ post.category }</Chip>
+                    <p className={ `text-4xl font-bold` }> { post.title }</p>
+                    <p className={ `text-xl` }> { post.subtitle }</p>
+                </div>
+
+                <div className={ `mx-2 -mt-2 mb-2 flex flex-row flex-wrap justify-between w-full` }>
+                    <div>
+                        <ul className={ `flex flex-row flex-wrap` }>
+                            {
+                                post.tags.map((tag: string, key: any) => (
+                                    <li key={ key } className={ `mx-1 mb-1` }>
+                                        <Chip>{ tag }</Chip>
+                                    </li>
+                                ))
+                            }
+                        </ul>
+                    </div>
+                    <div className={ `flex flex-row place-content-end mb-1 mr-6 items-center mx-1` }>
+                        <MdCalendarMonth />
+                        <p className={ `text-zinc-500 dark:text-zinc-400 ml-1` }>
+                            { (new Date(post.first_update)).toLocaleString('default', {
+                                month: `long`,
+                                day: `numeric`,
+                                year: `numeric`
+                            }) }
+                        </p>
+                    </div>
+                </div>
+            </div>
+
+        </>
+    );
+};
+export default Headers;

frontend/app/(pages)/blog/post/[id]/MinifyPostCard.tsx

@@ -0,0 +1,58 @@
+import React from 'react';
+import { Card, CardFooter, CardHeader } from '@nextui-org/card';
+import Image from 'next/image';
+import Link from 'next/link';
+
+type Props = {
+    post: any
+    desc: string
+}
+
+const MinifyPostCard = (props: Props) => {
+    const { post, desc } = props;
+    const img_url = post['header_img'] as string;
+    return (
+        <div className={ 'w-full transition hover:brightness-75' }>
+            <Card isFooterBlurred
+                  className="w-full h-[300px] shadow-none border-0 rounded-none overflow-hidden"
+                  as={ Link }
+                  isPressable
+                  href={ `/blog/post/${ post['id'] }` }
+            >
+                <CardHeader className="absolute z-10 top-1 flex-col items-start">
+                    <p className={ `text-tiny uppercase font-bold ${ img_url ? 'text-white/60' : 'text-black/60 dark:text-white/60' }` }>{ desc }</p>
+                </CardHeader>
+                { img_url &&
+                    <div className={ 'h-full' }>
+                        <div className={ 'relative h-[300px] overflow-hidden' }>
+                            <Image
+                                className={ 'object-cover object-center ' }
+                                src={ img_url }
+                                alt={ post.title }
+                                fill
+                            />
+                        </div>
+                        <CardFooter
+                            className="absolute transition-colors bg-zinc-300/80 dark:bg-gray-600/25 dark:backdrop-brightness-75 bottom-0  justify-between rounded-none">
+                            <div>
+                                <p className="text-2xl font-bold">{ post['title'] }</p>
+                                <p className="">{ post['sub_title'] }</p>
+                            </div>
+                        </CardFooter>
+                    </div>
+                }
+                { !img_url &&
+                    <div className={ 'h-full grid p-6 place-content-center' }>
+                        <div className={ 'flex flex-col max-h-fit text-left' }>
+                            <p className={ 'text-3xl font-bold text-balance' }>{ post['title'] }</p>
+                            <div className={ 'w-1/4 h-[2px] my-2 bg-zinc-500 dark:bg-zinc-400' }></div>
+                            <p className={ 'text-xl text-pretty break-words' }>{ post['sub_title'] }</p>
+                        </div>
+                    </div>
+                }
+            </Card>
+
+        </div>
+    );
+};
+export default MinifyPostCard;

frontend/app/(pages)/blog/post/[id]/PostCard.tsx

@@ -0,0 +1,55 @@
+import React from 'react';
+import { Card, CardBody } from '@nextui-org/card';
+import Headers from '@/app/(pages)/blog/post/[id]/Headers';
+import Footer from '@/app/(pages)/blog/post/[id]/Footer';
+import MarkdownRenderer from '@/app/(pages)/public/MarkdownRenderer';
+
+type Props = {
+    post: any
+}
+
+async function PostCard(props: Props) {
+    let post = props.post;
+    return (
+        <div>
+            <Card className={ `max-w-full relative` }>
+
+                {/* card headers */ }
+                <Headers title={ post.title }
+                         subtitle={ post.sub_title }
+                         summary={ post.summary }
+                         category={ post.category }
+                         tags={ post.tags }
+                         first_update={ post.first_update }
+                         header_img={ post.meta.header_img }
+                />
+
+                {/* card body */ }
+                <CardBody>
+                    <div className={ 'p-5' }>
+                        <MarkdownRenderer>
+                            { post.content }
+                        </MarkdownRenderer>
+                    </div>
+                </CardBody>
+
+
+                {/* card footer */ }
+                <Footer
+                    adjacent_posts={ post.adj }
+                    perm_link={ post.meta.link }
+                    author={ post.meta.author }
+                    author_link={ post.meta.author_link }
+                    first_update={ post.first_update }
+                    last_update={ post.last_update }
+                    cc={ post.meta.cc }
+                    post_id={ post.meta.id }
+                    title={ post.title }
+                />
+
+            </Card>
+        </div>
+    );
+}
+
+export default PostCard;

frontend/app/(pages)/blog/post/[id]/page.tsx

@@ -0,0 +1,70 @@
+import React, { cache } from 'react';
+import PostCard from '@/app/(pages)/blog/post/[id]/PostCard';
+import ButtonGoBack from '@/app/(pages)/blog/post/[id]/ButtonGoBack';
+import * as motion from 'motion/react-client';
+import { fetchNocturneApi } from '@/app/(pages)/blog/api';
+import { Metadata } from 'next';
+import { SITE_CONFIG } from '@/src/constants';
+
+const fetchPost = cache(async (id: string) => {
+    const res = await fetchNocturneApi(`/blog/get_post/${ id }`);
+    // throw Error('Not Found');
+    return await res.json();
+});
+
+export async function generateMetadata(
+    { params }: { params: Promise<{ id: string }> })
+    : Promise<Metadata> {
+    try {
+        const title = (await fetchPost((await params).id)).title as string;
+        return {
+            title: `${ title } - ${ SITE_CONFIG.name }`
+        };
+    } catch (e) {
+        return {
+            title: 'Unexpected Error'
+        };
+    }
+}
+
+async function BlogReader({
+    params
+}: {
+    params: Promise<{ id: string }>
+}) {
+    try {
+        let post = await fetchPost((await params).id);
+
+        return (
+            <motion.div
+                className={ `max-w-full` }
+                initial={ { y: 20, opacity: 0 } }
+                animate={ { y: 0, opacity: 1 } }
+                transition={ { ease: 'easeInOut', duration: 0.5 } }
+            >
+                <div className={ `max-w-full` }>
+                    <PostCard post={ post } />
+                </div>
+                <div className={ 'mt-3' }>
+                    <ButtonGoBack />
+                </div>
+            </motion.div>
+        );
+    } catch (e: any) {
+        return (
+            <div className={ `flex h-full w-full justify-center items-center` }>
+                <div className={ `flex-row` }>
+                    <p className={ `text-xl font-bold` }>
+                        { 'Unexpected Error:' }
+                    </p>
+                    <p className={ `font-bold` }>
+                        { e.message }
+                    </p>
+                </div>
+            </div>
+        );
+    }
+
+}
+
+export default BlogReader;

frontend/app/(pages)/friends/layout.tsx

@@ -0,0 +1,21 @@
+import React from 'react';
+import { Metadata } from 'next';
+import { SITE_CONFIG } from '@/src/constants';
+
+export const metadata: Metadata = {
+    title: `Friends - ${ SITE_CONFIG.name }`
+};
+
+function Layout({
+    children
+}: {
+    children: React.ReactNode;
+}) {
+    return (
+        <div className={ 'p-7' }>
+            { children }
+        </div>
+    );
+}
+
+export default Layout;

frontend/app/(pages)/friends/page.tsx

@@ -0,0 +1,93 @@
+import React from 'react';
+import { fetchJson } from '@/app/fetch';
+import { Card, CardBody } from '@nextui-org/react';
+import Image from 'next/image';
+import Link from 'next/link';
+
+export default async function Friends() {
+
+    const list = await fetchJson('https://raw.githubusercontent.com/Lumither/friends/master/friends.json');
+    const listLength = list.length;
+    const listMaxIdx = listLength - 1;
+    const listIsOdd = listLength % 2 !== 0;
+
+    return (
+        <div>
+            <div className={ `min-h-dvh pb-10` }>
+                <div className={ 'p-7 pt-[10%] md:pt-[20%]' }>
+                    <div className={ 'flex flex-col md:flex-row gap-x-3 justify-center' }>
+                        <p className={ 'text-3xl text-center text-balance' }>海内存知己</p>
+                        <p className={ 'text-3xl text-center text-balance' }>天涯若比邻</p>
+                    </div>
+                    <p className={ 'text-center text-balance text-zinc-500 dark:text-zinc-400' }>{ 'Though far apart, kin at heart' }</p>
+                </div>
+                <div className={ 'flex w-full h-full justify-center pt-3' }>
+                    <ul className={ 'grid grid-cols-2 gap-x-6 gap-y-3 md:max-w-[90%] xl:max-w-[85%] w-full' }>
+                        {
+                            list.map((friend: any, key: number) => (
+                                <li
+                                    key={ key }
+                                    className={ (key === listMaxIdx && listIsOdd) ? 'col-span-2 flex justify-center' : 'col-span-2 md:col-span-1' }
+                                >
+                                    <Card
+                                        isHoverable
+                                        isPressable
+                                        shadow={ 'none' }
+                                        as={ Link }
+                                        href={ friend['url'] }
+                                        className={ 'dark:bg-[#282830] w-full md:w-fit max-w-full shadow' }
+                                    >
+                                        <CardBody className={ 'overflow-visible pb-0.5' }>
+                                            <div className={ 'flex flex-row' }>
+                                                <div className={ 'flex p-2' }>
+                                                    <div
+                                                        className={ 'h-[80px] w-[80px] relative rounded-2xl' }>
+                                                        <Image
+                                                            alt="avatar"
+                                                            className="object-cover rounded-2xl z-10"
+                                                            fill
+                                                            unoptimized
+                                                            src={ friend['avatar'] }
+                                                        />
+                                                        <Image
+                                                            alt="avatar"
+                                                            className="relative object-cover rounded-2xl scale-110 blur-3xl"
+                                                            fill
+                                                            unoptimized
+                                                            src={ friend['avatar'] }
+                                                        />
+                                                    </div>
+                                                </div>
+                                                <div className={ 'p-2 flex-col max-w-full' }>
+                                                    <p className={ 'text-xl' }>{ friend['title'] }</p>
+                                                    { (friend['name'] === undefined || friend['name'].isNull) ??
+                                                        <p className={ 'text-zinc-600 dark:text-zinc-400' }>{ `@ ${ friend['name'] }` }</p> }
+                                                    { (friend['desc'] === undefined || friend['desc'].isNull) ??
+                                                        <p className={ 'text-sm text-pretty text-zinc-600 dark:text-zinc-300 mt-1' }>{ friend['desc'] }</p> }
+                                                </div>
+                                            </div>
+                                        </CardBody>
+                                        <div className={ 'h-2 relative w-full' }>
+                                            <Image
+                                                alt="theme bar"
+                                                draggable={ false }
+                                                className="object-cover object-center scale-110 blur-lg"
+                                                fill
+                                                unoptimized
+                                                src={ friend['avatar'] }
+                                            />
+                                        </div>
+                                    </Card>
+                                </li>
+                            ))
+                        }
+                    </ul>
+                </div>
+            </div>
+            <p className={ 'text-center' }>想要成为好伙伴嘛，向<span
+                className={ 'text-blue-800 dark:text-blue-500' }><Link
+                href={ 'https://github.com/Lumither/friends/' }>这里</Link></span>发起PR吧
+            </p>
+        </div>
+    );
+}

frontend/app/(pages)/layout.tsx

@@ -0,0 +1,30 @@
+import React from 'react';
+import Navbar from '@/components/Navbar';
+import Footer from '@/components/Footer';
+
+import * as motion from 'motion/react-client';
+
+function Layout({
+    children
+}: {
+    children: React.ReactNode;
+}) {
+    return (
+        <div>
+            <motion.div
+                initial={ { opacity: 0 } }
+                animate={ { opacity: 1 } }
+                transition={ { ease: 'easeInOut', duration: 0.3, delay: 0.5 } }
+                className={ `justify-center flex flex-row w-full max-w-full` }>
+                <Navbar />
+                <div className={ `flex flex-col flex-1 max-w-[1024px] min-w-0` }>
+                    { children }
+                    <Footer />
+                </div>
+            </motion.div>
+        </div>
+    )
+        ;
+}
+
+export default Layout;

frontend/app/(pages)/public/MarkdownRenderer.tsx

@@ -0,0 +1,64 @@
+import React from 'react';
+import Markdown from 'react-markdown';
+import remarkGfm from 'remark-gfm';
+import remarkToc from 'remark-toc';
+import remarkFrontmatter from 'remark-frontmatter';
+import rehypeRaw from 'rehype-raw';
+import rehypeSanitize from 'rehype-sanitize';
+import { Prism as SyntaxHighlighter } from 'react-syntax-highlighter';
+import { oneDark } from 'react-syntax-highlighter/dist/esm/styles/prism';
+
+const MarkdownRenderer = ({ children }: { children: React.ReactNode }) => {
+    return (
+        <div className={ 'w-full' }>
+            <Markdown
+                className={ `max-w-full text-justify text-pretty prose prose-sm prose-neutral dark:prose-invert
+                 md:prose-md lg:prose-lg prose-code:overflow-x-scroll`
+                }
+                remarkPlugins={ [ remarkGfm, remarkToc, remarkFrontmatter ] }
+                rehypePlugins={ [ rehypeRaw, rehypeSanitize ] }
+                components={ {
+                    pre(props) {
+                        const { node, className, children, ...rest } = props;
+                        if ((children as any)['type'] === 'code') {
+                            const match = /language-(\w+)/.exec((children as any)['props']['className'] || '');
+                            let lang = match ? match[1] : 'text';
+                            return (
+                                <pre className={ `not-prose` }>
+                                    <SyntaxHighlighter
+                                        // @ts-ignore
+                                        style={ oneDark }
+                                        language={ lang }
+                                        showLineNumbers
+                                        // wrapLongLines
+                                        // wrapLines
+                                        classNames={ className }
+                                        PreTag="div"
+                                        { ...rest }
+                                    >
+                                        {
+                                            String((children as any)['props']['children']).replace(/\n$/, '')
+                                        }
+                                    </SyntaxHighlighter>
+                                </pre>
+                            );
+                        } else {
+                            return (
+                                <pre className={ `not-prose` }>
+                                    <code className={ className } { ...props }>
+                                        { children }
+                                    </code>
+                               </pre>
+                            );
+                        }
+                    }
+                } }
+            >
+                {
+                    children as any
+                }
+            </Markdown>
+        </div>
+    );
+};
+export default MarkdownRenderer;

frontend/app/(pages)/public/screenSizeTrigger.ts

@@ -0,0 +1,35 @@
+import { useEffect, useState } from 'react';
+
+const screenSize = new Map<string, number>(
+    [
+        [ 'sm', 640 ],
+        [ 'md', 768 ],
+        [ 'lg', 1024 ],
+        [ 'xl', 1280 ],
+        [ '2xl', 2536 ]
+    ]
+);
+
+export const useScreenSizeTrigger = (size: number | string) => {
+    const criticalSize = (typeof size === 'string') ? (screenSize.get(size) ?? 768) : size;
+
+    const [ isCritical, setIsCritical ] = useState(false);
+    useEffect(() => {
+        const updateMobileWidth = () => {
+            if (window.innerWidth < criticalSize) {
+                setIsCritical(true);
+            } else {
+                setIsCritical(false);
+            }
+        };
+        updateMobileWidth();
+        window.addEventListener('resize', updateMobileWidth);
+        return () => {
+            window.removeEventListener('resize', updateMobileWidth);
+        };
+
+    });
+
+    return isCritical;
+
+};

frontend/app/(pages)/public/type/Result.ts

@@ -0,0 +1,7 @@
+export type Result<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};

frontend/app/(pages)/search/page.tsx

@@ -0,0 +1,13 @@
+import React from 'react';
+import ConstructionPlaceHolder from '@/components/ConstructionPlaceHolder';
+
+const Search = () => {
+    return (
+        <div className={ `h-dvh` }>
+            <ConstructionPlaceHolder />
+        </div>
+
+    );
+};
+
+export default Search;

frontend/app/Activities.tsx

@@ -0,0 +1,43 @@
+import React, { useEffect, useState } from 'react';
+import { Activity } from '@/src/HomePageActivities/activity';
+import { getGhActivities } from '@/src/HomePageActivities/ghActivity';
+import * as motion from 'motion/react-client';
+
+const Activities = () => {
+
+    const [ activities, setActivities ] = useState<Activity[] | null>(null);
+
+    useEffect(() => {
+        getGhActivities().then(data => setActivities(data));
+    }, []);
+
+    if (!activities) {
+        return (
+            <div>
+                <p>loading</p>
+            </div>
+        );
+    } else {
+        return (
+            <div>
+                <ul className={ 'flex flex-col gap-y-3 items-end' }>
+                    { activities.map((activity, key) => (
+                        <motion.div
+                            key={ key }
+                            initial={ { opacity: 0, y: 20 } }
+                            animate={ { opacity: 1, y: 0 } }
+                            transition={ { ease: 'easeInOut', duration: 0.2 } }
+                        >
+                            <li className={ 'backdrop-blur bg-white/75 dark:bg-black/45 rounded-xl w-fit' }>
+                                { activity.toElement() }
+                            </li>
+                        </motion.div>
+                    )) }
+                </ul>
+            </div>
+        );
+    }
+
+};
+
+export default Activities;

frontend/app/entries.tsx

@@ -0,0 +1,56 @@
+import React from 'react';
+import {
+    IoFlask,
+    IoHome,
+    IoInformationCircle,
+    IoLink,
+    IoLogoGithub,
+    IoMail,
+    IoPencil,
+    IoSearch
+} from 'react-icons/io5';
+
+export const entries: { display_name: string; href: string; icon: React.ReactNode }[] = [
+    {
+        icon: <IoHome size={ `20px` }></IoHome>,
+        display_name: 'Home',
+        href: '/'
+    },
+    {
+        icon: <IoInformationCircle size={ `20px` }></IoInformationCircle>,
+        display_name: 'About',
+        href: '/about'
+    },
+    {
+        icon: <IoPencil size={ `20px` }></IoPencil>,
+        display_name: 'Blog',
+        href: '/blog'
+    },
+    {
+        icon: <IoLink size={ `20px` }></IoLink>,
+        display_name: 'Friends',
+        href: '/friends'
+    },
+    {
+        icon: <IoSearch size={ `20px` }></IoSearch>,
+        display_name: 'Search',
+        href: '/search'
+    }, {
+        icon: <IoFlask size={ '20px' } />,
+        display_name: 'Lab',
+        href: 'https://lab.lmt.moe'
+    }
+];
+
+export const connections: { label: string, href: string, icon: React.ReactNode }[] = [
+    {
+        label: 'Github',
+        href: 'https://github.com/Lumither',
+        icon: <IoLogoGithub size={ `30px` } />
+    },
+    {
+        label: 'email',
+        href: 'mailto:lumither@outlook.com',
+        icon: <IoMail size={ `30px` } />
+    }
+];

frontend/app/fetch.ts

@@ -0,0 +1,17 @@
+export async function fetchText(url: string, ttl: number = 600) {
+    const res = await fetch(url, {
+        next: {
+            revalidate: ttl
+        }
+    });
+    return await res.text();
+}
+
+export async function fetchJson(url: string, ttl: number = 600) {
+    const res = await fetch(url, {
+        next: {
+            revalidate: ttl
+        }
+    });
+    return await res.json();
+}

frontend/app/globals.css

@@ -0,0 +1,13 @@
+@import "lxgw-wenkai-webfont/style.css";
+
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+body {
+    font-family: "LXGW WenKai", sans-serif;
+}
+
+pre, code {
+    font-family: "LXGW WenKai Mono", sans-serif;
+}

frontend/app/layout.tsx

@@ -0,0 +1,29 @@
+import type { Metadata } from 'next';
+import './globals.css';
+import React from 'react';
+import { ThemeProvider as NextThemesProvider } from 'next-themes';
+import { SITE_CONFIG } from '@/src/constants';
+
+export const metadata: Metadata = {
+    openGraph: {
+        siteName: SITE_CONFIG.name
+    },
+    title: SITE_CONFIG.name,
+    description: SITE_CONFIG.desc
+};
+
+export default function RootLayout({
+    children
+}: Readonly<{
+    children: React.ReactNode;
+}>) {
+    return (
+        <html lang="en" suppressHydrationWarning>
+        <body className={ `transition duration-300 dark:bg-[#282830] min-h-screen` }>
+        <NextThemesProvider attribute="class" defaultTheme="system">
+            { children }
+        </NextThemesProvider>
+        </body>
+        </html>
+    );
+}

frontend/app/page.tsx

@@ -0,0 +1,51 @@
+'use client';
+
+import React from 'react';
+import { useScreenSizeTrigger } from '@/app/(pages)/public/screenSizeTrigger';
+import { Button } from '@nextui-org/react';
+import { entries } from '@/app/entries';
+import Link from 'next/link';
+import { useLocalStorage } from 'react-use';
+
+export default function Home() {
+
+    const isMobile = useScreenSizeTrigger('lg');
+
+    const [ test, setTest, removeTest ] = useLocalStorage('test', 'test_value');
+    console.log(test);
+    // setTest('test value 2');
+    // console.log(test);
+    // removeTest();
+    // console.log(test);
+
+    return (
+        <div className={ `h-dvh relative` }>
+            <ul className={ `flex flex-col space-y-2 w-full` }>
+                {
+                    entries.map((meta, key) => (
+                        <li key={ key }>
+                            <Button
+                                as={ Link }
+                                variant={ `light` }
+                                color={ `default` }
+                                fullWidth
+                                isIconOnly={ isMobile }
+                                className={ 'flex lg:justify-start w-fit lg:w-full' }
+                                aria-label={ `navbar: ${ meta.display_name }` }
+                                href={ meta.href }
+                            >
+                                { meta.icon }
+                                <p className={ `font-bold hidden lg:block` }>{ meta.display_name }</p>
+                            </Button>
+                        </li>
+                    ))
+                }
+            </ul>
+            <div
+                className={ 'absolute bottom-0 w-full h-60 bg-yellow-500 p-12' }
+            >
+                <div className={ 'bg-blue-500 h-full w-full rounded-3xl backdrop-blur' }></div>
+            </div>
+        </div>
+    );
+}

frontend/app/providers.tsx

@@ -0,0 +1,12 @@
+'use client';
+
+import { NextUIProvider } from '@nextui-org/react';
+import React from 'react';
+
+export function Providers({ children }: { children: React.ReactNode }) {
+    return (
+        <NextUIProvider>
+            { children }
+        </NextUIProvider>
+    );
+}

frontend/components/ConstructionPlaceHolder.tsx

@@ -0,0 +1,13 @@
+import React from 'react';
+
+const ConstructionPlaceHolder = () => {
+    return (
+        <div className={ `flex h-full w-full justify-center items-center` }>
+            <p className={ `text-2xl font-bold` }>
+                正在施工中...
+            </p>
+        </div>
+    );
+};
+
+export default ConstructionPlaceHolder;

frontend/components/Footer.tsx

@@ -0,0 +1,25 @@
+import React from 'react';
+import Link from 'next/link';
+import { IoLogoGithub } from 'react-icons/io5';
+
+const Footer = () => {
+    return (
+        <div className={ `p-5 mb-4` }>
+            <div className={ `h-1 w-20 bg-zinc-500 dark:bg-zinc-400 mb-3` }></div>
+            <p>
+                © 2024-{ new Date().getFullYear() } <Link href={ `/about` }>Lumither Tao</Link>
+            </p>
+            <p>
+                Powered by Next.js and Rust, built with passion and love
+            </p>
+            <Link
+                href={ `https://github.com/Lumither/blog` }
+                aria-label={ `GitHub repo for this website` }
+            >
+                <IoLogoGithub className={ `mt-1` } />
+            </Link>
+        </div>
+    );
+};
+
+export default Footer;

frontend/components/Navbar.tsx

@@ -0,0 +1,116 @@
+'use client';
+
+import React, { useEffect, useState } from 'react';
+import { Button } from '@nextui-org/react';
+import Image from 'next/image';
+import Link from 'next/link';
+import ThemeSwitcher from '@/components/ThemeSwitcher';
+import { usePathname } from 'next/navigation';
+import { useScreenSizeTrigger } from '@/app/(pages)/public/screenSizeTrigger';
+import { connections, entries } from '@/app/entries';
+
+
+function Navbar() {
+
+    const path = usePathname();
+    const [ shownPath, setShownPath ] = useState(path);
+    useEffect(() => {
+        let trimmed_path = path.split(`/`)[1];
+        if (trimmed_path === '') {
+            setShownPath('HOME');
+        } else {
+            setShownPath(trimmed_path.toUpperCase());
+        }
+    }, [ path ]);
+
+    const isMobile = useScreenSizeTrigger('lg');
+
+    return (
+        <>
+            <div
+                className={ `flex flex-col min-w-[50px] lg:min-w-[200px] ml-2 mr-0 lg:ml-8 lg:mr-6 min-h-screen pt-8 sticky` }>
+                <div className={ `fixed min-h-screen h-full` }>
+                    <div className={ `hidden lg:block` }>
+                        <div className={ `flex justify-center items-center my-7 h-[200px] w-[200px]` }>
+                            <div className={ 'relative w-full h-full' }>
+                                <Image
+                                    src={ 'https://oss.lumither.com/blog/pictures/avatar.webp' }
+                                    alt={ 'avatar' }
+                                    fill
+                                    className={ 'rounded-full object-cover' }
+                                    loading={ 'eager' }
+                                ></Image>
+                            </div>
+                        </div>
+
+                        <div>
+                            <p className={ `font-bold text-2xl` }>Lumither Tao</p>
+                            <p className={ `text-xl text-zinc-500 dark:text-zinc-400` }>Ad Astra</p>
+                        </div>
+                    </div>
+
+                    <div>
+                        <ul className={ `flex flex-col space-y-2 lg:space-y-0 lg:flex-row items-center my-4 lg:space-x-2` }>
+                            {
+                                connections.map((conn, key) => (
+                                    <li key={ key }>
+                                        <Button as={ Link }
+                                                href={ conn.href }
+                                                aria-label={ conn.label }
+                                                variant={ `light` }
+                                                color={ `default` }
+                                                className={ `w-fit` }
+                                                isIconOnly
+                                        >
+                                            { conn.icon }
+                                        </Button>
+                                    </li>
+                                ))
+
+                            }
+                        </ul>
+                    </div>
+
+                    <div
+                        className={ `flex justify-center lg:justify-start w-full mt-8 ml-0 lg:-ml-3` }>
+                        <ul className={ `flex flex-col space-y-2 w-full` }>
+                            {
+                                entries.map((meta, key) => (
+                                    <li key={ key }>
+                                        <Button
+                                            as={ Link }
+                                            variant={ `light` }
+                                            color={ `default` }
+                                            fullWidth
+                                            isIconOnly={ isMobile }
+                                            className={ 'flex lg:justify-start w-fit lg:w-full' }
+                                            aria-label={ `navbar: ${ meta.display_name }` }
+                                            href={ meta.href }
+                                        >
+                                            { meta.icon }
+                                            <p className={ `font-bold hidden lg:block` }>{ meta.display_name }</p>
+                                        </Button>
+                                    </li>
+                                ))
+                            }
+                        </ul>
+                    </div>
+
+                    <div className={ `mt-8 flex lg:hidden justify-center w-full` }>
+                        <p className={ `text-center sideways-lr font-bold text-2xl text-zinc-500 dark:text-zinc-400` }>
+                            { shownPath }
+                        </p>
+                    </div>
+
+                    <div
+                        className={ `absolute bottom-16` }
+                    >
+                        <ThemeSwitcher />
+                    </div>
+                </div>
+            </div>
+        </>
+    );
+}
+
+export default Navbar;

frontend/components/ThemeSwitcher.tsx

@@ -0,0 +1,93 @@
+'use client';
+
+import React, { useEffect, useState } from 'react';
+import { useTheme } from 'next-themes';
+import { Button, Dropdown, DropdownItem, DropdownMenu, DropdownTrigger } from '@nextui-org/react';
+import { MdOutlineDarkMode, MdOutlineDesktopWindows, MdOutlineLightMode } from 'react-icons/md';
+import { useScreenSizeTrigger } from '@/app/(pages)/public/screenSizeTrigger';
+
+const switcherElements = new Map(
+    [
+        [ 'dark', {
+            'display_name': 'Dark Mode',
+            'icon': <MdOutlineDarkMode />
+        } ],
+        [ 'light', {
+            'display_name': 'Light Mode',
+            'icon': <MdOutlineLightMode />
+        } ],
+        [ 'system', {
+            'display_name': 'Follow System',
+            'icon': <MdOutlineDesktopWindows />
+        } ]
+    ]
+);
+
+function ThemeSwitcher() {
+    const [ mounted, setMounted ] = useState(false);
+    const { theme, setTheme } = useTheme();
+
+    const [ currTheme, setCurrTheme ] = useState(new Set([ theme as string ]));
+
+    const isMobile = useScreenSizeTrigger('lg');
+
+    useEffect(() => {
+        setMounted(true);
+    }, []);
+
+    if (!mounted) {
+        return null;
+    }
+
+    return (
+        <div className={ `` }>
+            <Dropdown backdrop={ 'blur' }>
+                <DropdownTrigger>
+                    <Button
+                        variant={ 'flat' }
+                        aria-label={ 'Theme Trigger' }
+                        fullWidth
+                        isIconOnly={ isMobile }
+                    >
+                        { switcherElements.get(currTheme.values().next().value as string)?.icon }
+                        <p className={ 'hidden lg:block' }>
+                            { switcherElements.get(currTheme.values().next().value as string)?.display_name }
+                        </p>
+                    </Button>
+                </DropdownTrigger>
+
+                <DropdownMenu
+                    aria-label={ 'Toggle Theme' }
+                    variant={ 'flat' }
+                    selectionMode={ 'single' }
+                    selectedKeys={ currTheme }
+                    onSelectionChange={ ({ anchorKey }) => {
+                        setCurrTheme(new Set([ anchorKey as string ]));
+                        setTheme(anchorKey as string);
+                    } }
+
+                >
+                    <DropdownItem
+                        key={ 'light' }
+                        startContent={ <MdOutlineLightMode /> }>
+                        Light Mode
+                    </DropdownItem>
+                    <DropdownItem
+                        key={ 'dark' }
+                        startContent={ <MdOutlineDarkMode /> }
+                    >
+                        Dark Mode
+                    </DropdownItem>
+                    <DropdownItem
+                        key={ 'system' }
+                        startContent={ <MdOutlineDesktopWindows /> }
+                    >
+                        Follow System
+                    </DropdownItem>
+                </DropdownMenu>
+            </Dropdown>
+        </div>
+    );
+}
+
+export default ThemeSwitcher;

frontend/next.config.mjs

@@ -0,0 +1,18 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+    images: {
+        remotePatterns: [
+            {
+                protocol: 'https',
+                hostname: 'oss.lumither.com'
+            },
+            {
+                protocol: 'https',
+                hostname: 'pic.re'
+            }
+        ]
+    },
+    output: 'standalone'
+};
+
+export default nextConfig;

frontend/package.json

@@ -1,44 +1,43 @@
 {
-  "name": "my-qwik-empty-starter",
-  "description": "Blank project with routing included",
-  "engines": {
-    "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-  },
-  "engines-annotation": "Mostly required by sharp which needs a Node-API v9 compatible runtime",
+  "name": "blog",
+  "version": "0.1.0",
   "private": true,
-  "trustedDependencies": [
-    "sharp"
-  ],
-  "trustedDependencies-annotation": "Needed for bun to allow running install scripts",
-  "type": "module",
   "scripts": {
-    "build": "qwik build",
-    "build.client": "vite build",
-    "build.preview": "vite build --ssr src/entry.preview.tsx",
-    "build.types": "tsc --incremental --noEmit",
-    "deploy": "echo 'Run \"npm run qwik add\" to install a server adapter'",
-    "dev": "vite --mode ssr",
-    "dev.debug": "node --inspect-brk ./node_modules/vite/bin/vite.js --mode ssr --force",
-    "fmt": "prettier --write .",
-    "fmt.check": "prettier --check .",
-    "lint": "eslint \"src/**/*.ts*\"",
-    "preview": "qwik build preview && vite preview --open",
-    "start": "vite --open --mode ssr",
-    "qwik": "qwik"
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint"
+  },
+  "dependencies": {
+    "@nextui-org/react": "^2.4.6",
+    "@types/react-syntax-highlighter": "^15.5.13",
+    "lxgw-wenkai-webfont": "^1.7.0",
+    "motion": "^12.3.1",
+    "next": "^15.0.3",
+    "next-themes": "^0.3.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-icons": "^5.2.1",
+    "react-markdown": "^9.0.1",
+    "react-syntax-highlighter": "^15.5.0",
+    "react-use": "^17.6.0",
+    "rehype-raw": "^7.0.0",
+    "rehype-sanitize": "^6.0.0",
+    "remark-frontmatter": "^5.0.0",
+    "remark-gfm": "^4.0.0",
+    "remark-toc": "^9.0.0",
+    "sharp": "^0.33.4"
   },
   "devDependencies": {
-    "@builder.io/qwik": "^1.12.0",
-    "@builder.io/qwik-city": "^1.12.0",
-    "@types/eslint": "8.56.10",
-    "@types/node": "20.14.11",
-    "@typescript-eslint/eslint-plugin": "7.16.1",
-    "@typescript-eslint/parser": "7.16.1",
-    "eslint": "8.57.0",
-    "eslint-plugin-qwik": "^1.12.0",
-    "prettier": "3.3.3",
-    "typescript": "5.4.5",
-    "undici": "*",
-    "vite": "5.3.5",
-    "vite-tsconfig-paths": "^4.2.1"
+    "@tailwindcss/typography": "^0.5.14",
+    "@types/node": "^20.14.15",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "autoprefixer": "^10.4.20",
+    "eslint": "^8.57.0",
+    "eslint-config-next": "14.2.2",
+    "postcss": "^8.4.41",
+    "tailwindcss": "^3.4.9",
+    "typescript": "^5.5.4"
   }
 }

frontend/postcss.config.mjs

@@ -0,0 +1,9 @@
+/** @type {import('postcss-load-config').Config} */
+const config = {
+    plugins: {
+        tailwindcss: {},
+        autoprefixer: {}
+    }
+};
+
+export default config;

frontend/public/favicon.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 500 500"><g clip-path="url(#a)"><circle cx="250" cy="250" r="250" fill="#fff"/><path fill="#18B6F6" d="m367.87 418.45-61.17-61.18-.94.13v-.67L175.7 227.53l32.05-31.13L188.9 87.73 99.56 199.09c-15.22 15.42-18.03 40.51-7.08 59.03l55.83 93.11a46.82 46.82 0 0 0 40.73 22.81l27.65-.27 151.18 44.68Z"/><path fill="#AC7EF4" d="m401.25 196.94-12.29-22.81-6.41-11.67-2.54-4.56-.26.26-33.66-58.63a47.07 47.07 0 0 0-41.27-23.75l-29.51.8-88.01.28a47.07 47.07 0 0 0-40.33 23.34L93.4 207l95.76-119.54L314.7 226.19l-22.3 22.67 13.35 108.54.13-.26v.26h-.26l.26.27 10.42 10.2 50.62 49.78c2.13 2 5.6-.4 4.13-2.96l-31.25-61.85 54.5-101.3 1.73-2c.67-.81 1.33-1.62 1.87-2.42a46.8 46.8 0 0 0 3.34-50.18Z"/><path fill="#fff" d="M315.1 225.65 189.18 87.6l17.9 108.14L175 227l130.5 130.27-11.75-108.14 21.37-23.48Z"/></g><defs><clipPath id="a"><path fill="#fff" d="M0 0h500v500H0z"/></clipPath></defs></svg>

frontend/public/manifest.json

@@ -1,9 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/web-manifest-combined.json",
-  "name": "qwik-project-name",
-  "short_name": "Welcome to Qwik",
-  "start_url": ".",
-  "display": "standalone",
-  "background_color": "#fff",
-  "description": "A Qwik project app."
-}

frontend/qwik.env.d.ts

@@ -1,4 +0,0 @@
-// This file can be used to add references for global types like `vite/client`.
-
-// Add global `vite/client` types. For more info, see: https://vitejs.dev/guide/features#client-types
-/// <reference types="vite/client" />

frontend/src/HomePageActivities/activity.tsx

@@ -0,0 +1,18 @@
+import React from 'react';
+
+
+export abstract class Activity {
+    protected constructor(
+        readonly time: Date
+    ) {
+    }
+
+    abstract toElement(): React.ReactElement;
+
+}
+
+export abstract class GhActivity extends Activity {
+    protected constructor(time: Date) {
+        super(time);
+    }
+}

frontend/src/HomePageActivities/constants.ts

@@ -0,0 +1 @@
+export const GH_USER_NAME = 'Lumither';

frontend/src/HomePageActivities/ghActivities/starRepo.tsx

@@ -0,0 +1,34 @@
+import { GhActivity } from '@/src/HomePageActivities/activity';
+import { Card, CardBody } from '@nextui-org/card';
+import Link from 'next/link';
+
+export class StarRepo extends GhActivity {
+    constructor(
+        readonly repoName: string,
+        readonly repoUrl: string,
+        time: Date
+    ) {
+        super(time);
+    }
+
+    toElement() {
+        return (
+            // <div>
+            //     <Link
+            //         href={ this.repoUrl }
+            //     >{ `${ GH_USER_NAME } started ${ this.repoName } at ${ this.time }` }</Link>
+            // </div>
+            <Card
+                isHoverable={ true }
+                as={ Link }
+                href={ this.repoUrl }
+                className={ 'bg-black/20' }
+            >
+                <CardBody>
+                    <p className={ 'text-sm' }>{ `Stared GitHub repository '${ this.repoName }'` }</p>
+                </CardBody>
+            </Card>
+
+        );
+    }
+}

frontend/src/HomePageActivities/ghActivity.tsx

@@ -0,0 +1,32 @@
+import { GhActivity } from '@/src/HomePageActivities/activity';
+import { match } from 'ts-pattern';
+import { StarRepo } from '@/src/HomePageActivities/ghActivities/starRepo';
+import { GH_USER_NAME } from '@/src/HomePageActivities/constants';
+
+
+export const getGhActivities: () => Promise<GhActivity[]> = async () => {
+    const data = await fetch(`https://api.github.com/users/${ GH_USER_NAME }/events`, {
+        headers: {
+            'Accept': 'application/vnd.github+json',
+            'X-GitHub-Api-Version': '2022-11-28'
+        }
+    });
+    return data
+        .json()
+        .then((ret: any): GhActivity[] => (
+            ret
+                .map((res: any) => (
+                    match(res)
+                        .returnType<GhActivity | undefined>()
+                        // star repo
+                        .with(
+                            { type: 'WatchEvent', payload: { action: 'started' } }
+                            , () => (
+                                new StarRepo(res.repo.name, res.repo.url, res.created_at)
+                            ))
+                        // to be continued
+                        .otherwise(() => undefined))
+                )
+                .filter((res: GhActivity | undefined) => res !== undefined)
+        ));
+};

frontend/src/components/router-head/router-head.tsx

@@ -1,48 +0,0 @@
-import { component$ } from "@builder.io/qwik";
-import { useDocumentHead, useLocation } from "@builder.io/qwik-city";
-
-/**
- * The RouterHead component is placed inside of the document `<head>` element.
- */
-export const RouterHead = component$(() => {
-  const head = useDocumentHead();
-  const loc = useLocation();
-
-  return (
-    <>
-      <title>{head.title}</title>
-
-      <link rel="canonical" href={loc.url.href} />
-      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-      <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-
-      {head.meta.map((m) => (
-        <meta key={m.key} {...m} />
-      ))}
-
-      {head.links.map((l) => (
-        <link key={l.key} {...l} />
-      ))}
-
-      {head.styles.map((s) => (
-        <style
-          key={s.key}
-          {...s.props}
-          {...(s.props?.dangerouslySetInnerHTML
-            ? {}
-            : { dangerouslySetInnerHTML: s.style })}
-        />
-      ))}
-
-      {head.scripts.map((s) => (
-        <script
-          key={s.key}
-          {...s.props}
-          {...(s.props?.dangerouslySetInnerHTML
-            ? {}
-            : { dangerouslySetInnerHTML: s.script })}
-        />
-      ))}
-    </>
-  );
-});

frontend/src/constants.ts

@@ -0,0 +1,4 @@
+export const SITE_CONFIG = {
+    name: 'Atelier Lumiaethor',
+    desc: ''
+};

frontend/src/entry.dev.tsx

@@ -1,17 +0,0 @@
-/*
- * WHAT IS THIS FILE?
- *
- * Development entry point using only client-side modules:
- * - Do not use this mode in production!
- * - No SSR
- * - No portion of the application is pre-rendered on the server.
- * - All of the application is running eagerly in the browser.
- * - More code is transferred to the browser than in SSR mode.
- * - Optimizer/Serialization/Deserialization code is not exercised!
- */
-import { render, type RenderOptions } from "@builder.io/qwik";
-import Root from "./root";
-
-export default function (opts: RenderOptions) {
-  return render(document, <Root />, opts);
-}

frontend/src/entry.preview.tsx

@@ -1,21 +0,0 @@
-/*
- * WHAT IS THIS FILE?
- *
- * It's the bundle entry point for `npm run preview`.
- * That is, serving your app built in production mode.
- *
- * Feel free to modify this file, but don't remove it!
- *
- * Learn more about Vite's preview command:
- * - https://vitejs.dev/config/preview-options.html#preview-options
- *
- */
-import { createQwikCity } from "@builder.io/qwik-city/middleware/node";
-import qwikCityPlan from "@qwik-city-plan";
-// make sure qwikCityPlan is imported before entry
-import render from "./entry.ssr";
-
-/**
- * The default export is the QwikCity adapter used by Vite preview.
- */
-export default createQwikCity({ render, qwikCityPlan });

frontend/src/entry.ssr.tsx

@@ -1,33 +0,0 @@
-/**
- * WHAT IS THIS FILE?
- *
- * SSR entry point, in all cases the application is rendered outside the browser, this
- * entry point will be the common one.
- *
- * - Server (express, cloudflare...)
- * - npm run start
- * - npm run preview
- * - npm run build
- *
- */
-import {
-  renderToStream,
-  type RenderToStreamOptions,
-} from "@builder.io/qwik/server";
-import { manifest } from "@qwik-client-manifest";
-import Root from "./root";
-
-export default function (opts: RenderToStreamOptions) {
-  return renderToStream(<Root />, {
-    manifest,
-    ...opts,
-    // Use container attributes to set attributes on the html tag.
-    containerAttributes: {
-      lang: "en-us",
-      ...opts.containerAttributes,
-    },
-    serverData: {
-      ...opts.serverData,
-    },
-  });
-}

frontend/src/root.tsx

@@ -1,38 +0,0 @@
-import { component$ } from "@builder.io/qwik";
-import {
-  QwikCityProvider,
-  RouterOutlet,
-  ServiceWorkerRegister,
-} from "@builder.io/qwik-city";
-import { RouterHead } from "./components/router-head/router-head";
-import { isDev } from "@builder.io/qwik";
-
-import "./global.css";
-
-export default component$(() => {
-  /**
-   * The root of a QwikCity site always start with the <QwikCityProvider> component,
-   * immediately followed by the document's <head> and <body>.
-   *
-   * Don't remove the `<head>` and `<body>` elements.
-   */
-
-  return (
-    <QwikCityProvider>
-      <head>
-        <meta charset="utf-8" />
-        {!isDev && (
-          <link
-            rel="manifest"
-            href={`${import.meta.env.BASE_URL}manifest.json`}
-          />
-        )}
-        <RouterHead />
-      </head>
-      <body lang="en">
-        <RouterOutlet />
-        {!isDev && <ServiceWorkerRegister />}
-      </body>
-    </QwikCityProvider>
-  );
-});

frontend/src/routes/index.tsx

@@ -1,25 +0,0 @@
-import { component$ } from "@builder.io/qwik";
-import type { DocumentHead } from "@builder.io/qwik-city";
-
-export default component$(() => {
-  return (
-    <>
-      <h1>Hi 👋</h1>
-      <div>
-        Can't wait to see what you build with qwik!
-        <br />
-        Happy coding.
-      </div>
-    </>
-  );
-});
-
-export const head: DocumentHead = {
-  title: "Welcome to Qwik",
-  meta: [
-    {
-      name: "description",
-      content: "Qwik site description",
-    },
-  ],
-};

frontend/src/routes/layout.tsx

@@ -1,17 +0,0 @@
-import { component$, Slot } from "@builder.io/qwik";
-import type { RequestHandler } from "@builder.io/qwik-city";
-
-export const onGet: RequestHandler = async ({ cacheControl }) => {
-  // Control caching for this request for best performance and to reduce hosting costs:
-  // https://qwik.dev/docs/caching/
-  cacheControl({
-    // Always serve a cached response by default, up to a week stale
-    staleWhileRevalidate: 60 * 60 * 24 * 7,
-    // Max once every 5 seconds, revalidate on the server to get a fresh version of this page
-    maxAge: 5,
-  });
-};
-
-export default component$(() => {
-  return <Slot />;
-});

frontend/src/routes/service-worker.ts

@@ -1,18 +0,0 @@
-/*
- * WHAT IS THIS FILE?
- *
- * The service-worker.ts file is used to have state of the art prefetching.
- * https://qwik.dev/qwikcity/prefetching/overview/
- *
- * Qwik uses a service worker to speed up your site and reduce latency, ie, not used in the traditional way of offline.
- * You can also use this file to add more functionality that runs in the service worker.
- */
-import { setupServiceWorker } from "@builder.io/qwik-city/service-worker";
-
-setupServiceWorker();
-
-addEventListener("install", () => self.skipWaiting());
-
-addEventListener("activate", () => self.clients.claim());
-
-declare const self: ServiceWorkerGlobalScope;

frontend/tailwind.config.ts

@@ -0,0 +1,60 @@
+import { nextui } from '@nextui-org/react';
+
+import type { Config } from 'tailwindcss';
+import plugin from 'tailwindcss/plugin';
+
+const config: Config = {
+    content: [
+        './pages/**/*.{js,ts,jsx,tsx,mdx}',
+        './components/**/*.{js,ts,jsx,tsx,mdx}',
+        './app/**/*.{js,ts,jsx,tsx,mdx}',
+        './node_modules/@nextui-org/theme/dist/**/*.{js,ts,jsx,tsx}'
+    ],
+    // theme: {
+    //     extend: {}
+    // },
+    darkMode: 'class',
+    plugins: [
+        require('@tailwindcss/typography'),
+        nextui(
+            {
+                // defaultTheme: 'dark',
+                defaultExtendTheme: 'light',
+                themes: {
+                    'light': {
+                        layout: {},
+                        colors: {}
+                    },
+                    'dark': {
+                        layout: {},
+                        colors: {}
+                    }
+                }
+            }
+        ),
+        plugin(function ({ addUtilities, addComponents, e, config }) {
+            addUtilities(
+                {
+                    '.horizontal-tb': {
+                        writingMode: 'horizontal-tb'
+                    },
+                    '.vertical-rl': {
+                        writingMode: 'vertical-rl'
+                    },
+                    '.vertical-lr': {
+                        writingMode: 'vertical-lr'
+                    },
+                    '.sideways-lr': {
+                        writingMode: 'vertical-lr',
+                        transform: 'rotate(180deg)'
+                    },
+                    '.sideways-rl': {
+                        writingMode: 'sideways-rl',
+                        transform: 'rotate(180deg)'
+                    }
+                }
+            );
+        })
+    ]
+};
+export default config;

frontend/tsconfig.json

@@ -1,25 +1,27 @@
 {
   "compilerOptions": {
+    "lib": ["dom", "dom.iterable", "esnext"],
     "allowJs": true,
-    "target": "ES2017",
-    "module": "ES2022",
-    "lib": ["es2022", "DOM", "WebWorker", "DOM.Iterable"],
-    "jsx": "react-jsx",
-    "jsxImportSource": "@builder.io/qwik",
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "Bundler",
-    "esModuleInterop": true,
     "skipLibCheck": true,
-    "incremental": true,
-    "isolatedModules": true,
-    "outDir": "tmp",
+    "strict": true,
+    "target": "ESNext",
     "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
     "paths": {
-      "~/*": ["./src/*"]
+      "@/*": ["./*"]
     }
   },
-  "files": ["./.eslintrc.cjs"],
-  "include": ["src", "./*.d.ts", "./*.config.ts"]
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
 }

frontend/vite.config.ts

@@ -1,106 +0,0 @@
-/**
- * This is the base config for vite.
- * When building, the adapter config is used which loads this file and extends it.
- */
-import { defineConfig, type UserConfig } from "vite";
-import { qwikVite } from "@builder.io/qwik/optimizer";
-import { qwikCity } from "@builder.io/qwik-city/vite";
-import tsconfigPaths from "vite-tsconfig-paths";
-import pkg from "./package.json";
-
-type PkgDep = Record<string, string>;
-const { dependencies = {}, devDependencies = {} } = pkg as any as {
-  dependencies: PkgDep;
-  devDependencies: PkgDep;
-  [key: string]: unknown;
-};
-errorOnDuplicatesPkgDeps(devDependencies, dependencies);
-
-/**
- * Note that Vite normally starts from `index.html` but the qwikCity plugin makes start at `src/entry.ssr.tsx` instead.
- */
-export default defineConfig(({ command, mode }): UserConfig => {
-  return {
-    plugins: [qwikCity(), qwikVite(), tsconfigPaths()],
-    // This tells Vite which dependencies to pre-build in dev mode.
-    optimizeDeps: {
-      // Put problematic deps that break bundling here, mostly those with binaries.
-      // For example ['better-sqlite3'] if you use that in server functions.
-      exclude: [],
-    },
-
-    /**
-     * This is an advanced setting. It improves the bundling of your server code. To use it, make sure you understand when your consumed packages are dependencies or dev dependencies. (otherwise things will break in production)
-     */
-    // ssr:
-    //   command === "build" && mode === "production"
-    //     ? {
-    //         // All dev dependencies should be bundled in the server build
-    //         noExternal: Object.keys(devDependencies),
-    //         // Anything marked as a dependency will not be bundled
-    //         // These should only be production binary deps (including deps of deps), CLI deps, and their module graph
-    //         // If a dep-of-dep needs to be external, add it here
-    //         // For example, if something uses `bcrypt` but you don't have it as a dep, you can write
-    //         // external: [...Object.keys(dependencies), 'bcrypt']
-    //         external: Object.keys(dependencies),
-    //       }
-    //     : undefined,
-
-    server: {
-      headers: {
-        // Don't cache the server response in dev mode
-        "Cache-Control": "public, max-age=0",
-      },
-    },
-    preview: {
-      headers: {
-        // Do cache the server response in preview (non-adapter production build)
-        "Cache-Control": "public, max-age=600",
-      },
-    },
-  };
-});
-
-// *** utils ***
-
-/**
- * Function to identify duplicate dependencies and throw an error
- * @param {Object} devDependencies - List of development dependencies
- * @param {Object} dependencies - List of production dependencies
- */
-function errorOnDuplicatesPkgDeps(
-  devDependencies: PkgDep,
-  dependencies: PkgDep,
-) {
-  let msg = "";
-  // Create an array 'duplicateDeps' by filtering devDependencies.
-  // If a dependency also exists in dependencies, it is considered a duplicate.
-  const duplicateDeps = Object.keys(devDependencies).filter(
-    (dep) => dependencies[dep],
-  );
-
-  // include any known qwik packages
-  const qwikPkg = Object.keys(dependencies).filter((value) =>
-    /qwik/i.test(value),
-  );
-
-  // any errors for missing "qwik-city-plan"
-  // [PLUGIN_ERROR]: Invalid module "@qwik-city-plan" is not a valid package
-  msg = `Move qwik packages ${qwikPkg.join(", ")} to devDependencies`;
-
-  if (qwikPkg.length > 0) {
-    throw new Error(msg);
-  }
-
-  // Format the error message with the duplicates list.
-  // The `join` function is used to represent the elements of the 'duplicateDeps' array as a comma-separated string.
-  msg = `
-    Warning: The dependency "${duplicateDeps.join(", ")}" is listed in both "devDependencies" and "dependencies".
-    Please move the duplicated dependencies to "devDependencies" only and remove it from "dependencies"
-  `;
-
-  // Throw an error with the constructed message.
-  if (duplicateDeps.length > 0) {
-    throw new Error(msg);
-  }
-}