feat(frontend) qwik init

backend/Cargo.toml

@@ -1,8 +1,7 @@
 [workspace]
 resolver = "2"
 members = [
-    "api_server",
+    "server",
-    "constants",
     "macros",
     "markdown",
 ]

backend/api_server/Cargo.toml

@@ -1,25 +0,0 @@
-[package]
-name = "api_server"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-macros = { path = "../macros" }
-constants = { path = "../constants" }
-markdown = { path = "../markdown" }
-chrono = { version = "0.4.38", features = ["serde", "alloc"] }
-tracing = "0.1.40"
-tracing-subscriber = { version = "0.3.18", features = ["env-filter", "fmt"] }
-tracing-appender = "0.2.3"
-dotenv = "0.15.0"
-dirs = "5.0.1"
-tokio = { version = "1.40.0", features = ["full"] }
-sqlx = { version = "0.8.2", features = ["runtime-tokio", "tls-native-tls", "postgres", "chrono", "uuid"] }
-axum = { version = "0.7.5", features = ["macros"] }
-serde = { version = "1.0.199", features = ["derive"] }
-serde_json = "1.0.128"
-uuid = { version = "1.10.0", features = ["v4", "fast-rng", "serde"] }
-futures = { version = "0.3.30", features = ["executor"] }
-cron = "0.13.0"
-git2 = "0.19.0"
-thiserror = "2.0.3"

backend/api_server/src/blog/api/get_page_count.rs

@@ -1,26 +0,0 @@
-use constants::blog::PAGE_SIZE;
-
-use axum::extract::State;
-use axum::Json;
-use serde_json::{json, Value};
-use sqlx::{query, PgPool, Row};
-use tracing::error;
-
-pub async fn get_page_count(
-    State(db_connection): State<PgPool>,
-) -> Result<Json<Value>, Json<Value>> {
-    match query("select cast(ceil(count(*) / $1) as integer) as res from post")
-        .bind(PAGE_SIZE as f32)
-        .fetch_one(&db_connection)
-        .await
-    {
-        Ok(res) => {
-            let res: i32 = res.get("res");
-            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/api_server/src/blog/api/get_post.rs

@@ -1,153 +0,0 @@
-use axum::{
-    extract::{Path, State},
-    http::StatusCode,
-    Json,
-};
-use serde_json::{json, Value};
-use sqlx::{query, Error, PgPool, Row};
-use std::str::FromStr;
-use tracing::error;
-use uuid::Uuid;
-
-pub async fn get_post(
-    State(db_connection): State<PgPool>,
-    Path(post_id): Path<String>,
-) -> Result<Json<Value>, (StatusCode, Json<Value>)> {
-    let post_id = match Uuid::from_str(post_id.as_str()) {
-        Ok(id) => id,
-        Err(e) => {
-            error!(
-                "Failed to parse UUID <{}>: {}",
-                post_id.as_str(),
-                e.to_string()
-            );
-            return Err((
-                StatusCode::BAD_REQUEST,
-                Json::from(json!(("error", e.to_string()))),
-            ));
-        }
-    };
-
-    let post = match query(
-        r#"
-SELECT jsonb_strip_nulls(to_jsonb(t.*)) - 'post_id' AS post
-FROM post t
-WHERE post_id = $1;
-"#,
-    )
-    .bind(post_id)
-    .fetch_one(&db_connection)
-    .await
-    {
-        Ok(value) => value.get::<Value, _>("post"),
-        Err(e) => {
-            error!(
-                "Database error on Reading `base post information` from table `post`: <{}>: {}",
-                post_id.to_string(),
-                e.to_string()
-            );
-            return match e {
-                Error::RowNotFound => Err((
-                    StatusCode::BAD_REQUEST,
-                    Json::from(json!({"error": e.to_string()})),
-                )),
-                _ => Err((
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    Json::from(json!({"error": e.to_string()})),
-                )),
-            };
-        }
-    };
-
-    let tags: Vec<_> = match query("SELECT tag FROM Tag WHERE post_id = $1;")
-        .bind(post_id)
-        .fetch_all(&db_connection)
-        .await
-    {
-        Ok(tags) => tags.iter().map(|tag| tag.get::<String, _>("tag")).collect(),
-        Err(e) => {
-            error!("Database query error :{}", e.to_string());
-            return Err((
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Json::from(json!({"error": e.to_string()})),
-            ));
-        }
-    };
-
-    let meta = 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) => value.get::<Value, _>("meta"),
-        Err(e) => {
-            error!(
-                "Database error on Reading `{}` from table `{}`: <{}>: {}",
-                "post meta data",
-                "meta",
-                post_id.to_string(),
-                e.to_string()
-            );
-            return Err((
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Json::from(json!({"error": e.to_string()})),
-            ));
-        }
-    };
-
-    let adjacent = match query(r"
-WITH target_post AS (SELECT t.date FROM meta t WHERE post_id = $1),
-     prev AS (SELECT post_id, t.title, t.sub_title, t.header_img
-              FROM meta t
-              WHERE t.date < (SELECT date FROM target_post)
-              ORDER BY t.date DESC
-              LIMIT 1),
-     next AS (SELECT post_id, t.title, t.sub_title, t.header_img
-              FROM meta t
-              WHERE t.date > (SELECT date FROM target_post)
-              ORDER BY t.date
-              LIMIT 1)
-SELECT json_strip_nulls(json_build_object(
-        'prev',
-        (SELECT json_build_object('id', post_id, 'title', title, 'sub_title', sub_title, 'header_img', header_img)
-         FROM prev),
-        'next',
-        (SELECT json_build_object('id', post_id, 'title', title, 'sub_title', sub_title, 'header_img', header_img)
-         FROM next)
-                        )) AS result;
-"
-    )
-        .bind(post_id)
-        .fetch_one(&db_connection)
-        .await
-    {
-        Ok(res) => {res.get::<Value, _>("result")}
-        Err(e) => {
-            error!(
-                "Database error on Reading `{}` from table `{}`: <{}>: {}",
-                "adjoint posts data",
-                "meta",
-                post_id.to_string(),
-                e.to_string()
-            );
-            return Err((
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Json::from(json!({"error": e.to_string()})),
-            ));
-        }
-
-    };
-
-    let mut res = post.as_object().unwrap().to_owned();
-    res.insert("tags".to_string(), tags.into());
-    res.insert("meta".to_string(), meta);
-    res.insert("adj".to_string(), adjacent);
-
-    Ok(Json::from(json!(res)))
-}

backend/api_server/src/blog/api/get_post_list.rs

@@ -1,130 +0,0 @@
-use std::error::Error;
-
-use 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/api_server/src/blog/api/mod.rs

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

backend/api_server/src/blog/cron/check_update/error.rs

@@ -1,49 +0,0 @@
-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/api_server/src/blog/cron/check_update/index.rs

@@ -1,351 +0,0 @@
-use std::error::Error;
-use std::path::Path;
-
-use crate::blog::cron::check_update::utils::get_md_file_basename;
-use crate::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/api_server/src/blog/cron/check_update/mod.rs

@@ -1,146 +0,0 @@
-use std::env;
-use std::error::Error;
-use std::fs::remove_dir_all;
-use std::path::{Path, PathBuf};
-
-use crate::{
-    blog::cron::check_update::{
-        index::drop_index,
-        utils::{expand_path, get_md_file_basename, index_files, search_md},
-    },
-    utils::git,
-};
-use constants::config::general::{default_value, var_name};
-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 {
-                                    match drop_index(
-                                        &get_md_file_basename(
-                                            path.file_name().unwrap().to_str().unwrap(),
-                                        ),
-                                        db_connection,
-                                    ) {
-                                        Ok(_) => info!(
-                                            "blog content git({}) file `{}` is detected as deleted/untracked, index dropped",
-                                            &git_url,
-                                            &path.display()
-                                        ),
-                                        Err(e) => error!(
-                                            "blog content git({}) file `{}` is detected as deleted/untracked, failed to drop index: {}",
-                                            &git_url,
-                                            &path.display(),
-                                            e
-                                        )
-                                    }
-                                }
-                            } 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());
-                                    update_md.push(dbg!(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/api_server/src/blog/cron/check_update/utils.rs

@@ -1,86 +0,0 @@
-use dirs::home_dir;
-use std::path::PathBuf;
-
-use crate::blog::cron::check_update::index::index_file;
-use chrono::{DateTime, FixedOffset, ParseResult};
-use constants::config::general::{default_value, var_name};
-use constants::time::DEFAULT_DATE_FORMAT;
-
-use futures::executor::block_on;
-use futures::future::join_all;
-use sqlx::{Pool, Postgres};
-use tokio::runtime::Runtime;
-use tokio::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 = dbg!(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/api_server/src/blog/cron/mod.rs

@@ -1,15 +0,0 @@
-use crate::scheduler::tasks::basic::BasicTask;
-use crate::scheduler::tasks::Task;
-use sqlx::{Pool, Postgres};
-
-pub mod check_update;
-
-pub fn get_tasks(db_connection: Pool<Postgres>) -> Vec<Box<dyn Task>> {
-    let db_conn_clone = db_connection.clone();
-    vec![
-        // BasicTask::new(move || check_update::task(&db_conn_clone), "0/15 * * * * *")
-        BasicTask::new(move || check_update::task(&db_conn_clone), "* * * * * *")
-            .unwrap()
-            .to_task(),
-    ]
-}

backend/api_server/src/blog/mod.rs

@@ -1,17 +0,0 @@
-mod api;
-pub mod cron;
-
-use crate::blog::api::{
-    get_page_count::get_page_count, get_post::get_post, get_post_list::get_post_list,
-};
-
-use axum::routing::get;
-use axum::Router;
-use sqlx::{Pool, Postgres};
-
-pub fn get_router() -> Router<Pool<Postgres>> {
-    Router::new()
-        .route("/get_post_list", get(get_post_list))
-        .route("/get_page_count", get(get_page_count))
-        .route("/get_post/:post_id", get(get_post))
-}

backend/api_server/src/init/cron.rs

@@ -1,12 +0,0 @@
-use crate::blog;
-use crate::scheduler::Scheduler;
-use sqlx::{Pool, Postgres};
-
-pub fn start(db_pool: Pool<Postgres>) {
-    let scheduler = Scheduler::new();
-    let _ = vec![blog::cron::get_tasks(db_pool.clone())]
-        .into_iter()
-        .map(|list| scheduler.insert_list(list))
-        .collect::<Vec<_>>();
-    scheduler.start().unwrap()
-}

backend/api_server/src/init/database.rs

@@ -1,41 +0,0 @@
-use std::env;
-use std::error::Error;
-use std::str::FromStr;
-
-use 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: temporal 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/api_server/src/init/logger.rs

@@ -1,106 +0,0 @@
-use std::path::Path;
-use std::{env, io};
-
-use chrono::Local;
-use constants::config::general::{default_value, var_name};
-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(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/api_server/src/init/misc.rs

@@ -1,14 +0,0 @@
-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/api_server/src/init/mod.rs

@@ -1,58 +0,0 @@
-mod cron;
-mod database;
-pub mod logger;
-mod misc;
-mod schema;
-pub mod server;
-
-use macros::panic_with_log;
-use std::{env, panic};
-use tracing::{info, Level};
-
-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) => {
-            panic_with_log!(
-                Level::ERROR,
-                "database connection pool failed to initialize: {}",
-                e
-            );
-        }
-    };
-
-    // schema init
-    schema::init(&db_pool).await;
-
-    // load cron task
-    cron::start(db_pool.clone());
-
-    // api serve
-    match server::start(db_pool).await {
-        Ok(_) => {}
-        Err(e) => {
-            panic_with_log!(Level::ERROR, "server panicked: {}", e)
-        }
-    }
-}

backend/api_server/src/init/schema.rs

@@ -1,49 +0,0 @@
-use sqlx::{query, Pool, Postgres};
-use tracing::info;
-
-const POST_BASE_MODEL: &str = r##"
-CREATE TABLE IF NOT EXISTS Post
-(
-    post_id      UUID PRIMARY KEY,
-    title        VARCHAR(255) NOT NULL,
-    category     VARCHAR(255) NOT NULL,
-    filename     TEXT UNIQUE  NOT NULL,
-    summary      TEXT,
-    sub_title    TEXT,
-    content      TEXT         NOT NULL,
-    last_update  TIMESTAMPTZ,
-    first_update TIMESTAMPTZ  NOT NULL
-);
-"##;
-
-// base model, will add more cols at runtime
-const POST_META_MODEL: &str = r##"
-CREATE TABLE IF NOT EXISTS Meta
-(
-    post_id      UUID PRIMARY KEY
-);
-"##;
-
-const POST_HASH_MODEL: &str = r##"
-CREATE TABLE IF NOT EXISTS Hash
-(
-    post_id      UUID PRIMARY KEY,
-    hash         VARCHAR(44)
-);
-"##;
-
-const TAG_MODEL: &str = r##"
-CREATE TABLE IF NOT EXISTS Tag
-(
-    post_id UUID         NOT NULL,
-    tag     VARCHAR(255) NOT NULL
-);
-"##;
-
-pub async fn init(db_connection: &Pool<Postgres>) {
-    query(POST_BASE_MODEL).execute(db_connection).await.unwrap();
-    query(POST_META_MODEL).execute(db_connection).await.unwrap();
-    query(TAG_MODEL).execute(db_connection).await.unwrap();
-    query(POST_HASH_MODEL).execute(db_connection).await.unwrap();
-    info!("database schema initialized");
-}

backend/api_server/src/init/server.rs

@@ -1,52 +0,0 @@
-use std::env;
-use std::error::Error;
-use std::num::ParseIntError;
-use std::process::exit;
-
-use crate::blog;
-use axum::Router;
-use constants::config::server::{default_value, var_name};
-use macros::panic_with_log;
-use sqlx::{Pool, Postgres};
-use tracing::{error, info, warn, Level};
-
-pub async fn start(db_pool: Pool<Postgres>) -> Result<(), Box<dyn Error>> {
-    let app = Router::new()
-        .nest("/blog", blog::get_router())
-        .with_state(db_pool);
-
-    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) => {
-                panic_with_log!(
-                    Level::ERROR,
-                    "failed to start server on {}:{}: {}",
-                    default_value::HOST,
-                    port,
-                    e.to_string()
-                );
-            }
-        };
-
-    axum::serve(listener, app).await.unwrap_or_else(|e| {
-        error!("failed to start axum: {}", e.to_string());
-        exit(1);
-    });
-    Ok(())
-}

backend/api_server/src/main.rs

@@ -1,13 +0,0 @@
-mod blog;
-mod init;
-mod scheduler;
-mod utils;
-
-#[tokio::main]
-async fn main() {
-    init::load_env();
-
-    let _guards = init::logger::init();
-
-    init::start().await;
-}

backend/api_server/src/scheduler/mod.rs

@@ -1,194 +0,0 @@
-use crate::{
-    scheduler::scheduler_error::SchedulerError,
-    scheduler::scheduler_error::SchedulerError::IdAlreadyRunning,
-    scheduler::scheduler_error::SchedulerError::IdNotFound, scheduler::sleeper::SkippableSleeper,
-    scheduler::tasks::Task,
-};
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::RwLock;
-use std::{collections::HashMap, sync::Arc, thread};
-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 Task>>>>>,
-    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 Task>>,
-    ) -> 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 Task>) -> 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 Task>>) -> 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/api_server/src/scheduler/scheduler_error.rs

@@ -1,44 +0,0 @@
-use crate::scheduler::scheduler_error::SchedulerError::MutexPoison;
-use std::error::Error;
-use std::fmt::{Debug, Display, Formatter};
-use std::sync::PoisonError;
-
-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/api_server/src/scheduler/sleeper.rs

@@ -1,77 +0,0 @@
-use chrono::{DateTime, Utc};
-use std::sync::{Arc, Condvar, Mutex};
-use std::thread;
-use std::time::Duration;
-
-#[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/api_server/src/scheduler/task_func.rs

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

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

@@ -1,37 +0,0 @@
-use crate::scheduler::task_func::TaskFunc;
-use crate::scheduler::tasks::Task;
-use chrono::{DateTime, Utc};
-use cron::Schedule;
-use std::error::Error;
-use std::str::FromStr;
-
-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 Task> {
-        Box::new(self)
-    }
-}
-
-impl Task for BasicTask {
-    fn get_next_execution(&self) -> Option<DateTime<Utc>> {
-        self.schedule.upcoming(Utc).next()
-    }
-
-    fn call(&self) {
-        (self.func)()
-    }
-}

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

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

backend/api_server/src/utils/git.rs

@@ -1,195 +0,0 @@
-/// 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,
-}
-
-fn do_fetch<'a>(
-    repo: &'a Repository,
-    refs: &[&str],
-    remote: &'a mut Remote,
-) -> Result<AnnotatedCommit<'a>, git2::Error> {
-    let mut fetch_option = FetchOptions::new();
-
-    // Always fetch all tags.
-    // Perform a download and also update tips
-    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)
-}
-
-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()
-            // For some reason, the force is required to make the working directory actually get updated
-            // I suspect we should be adding some logic to handle dirty working directory states,
-            // but this is just an example so maybe not.
-            .force(),
-    ))?;
-    Ok(())
-}
-
-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)?)?;
-    // now create the merge commit
-    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())?;
-
-    // Do our merge commit and set the current branch head to that commit.
-    let _merge_commit = repo.commit(
-        Some("HEAD"),
-        &sig,
-        &sig,
-        &msg,
-        &result_tree,
-        &[&local_commit, &remote_commit],
-    )?;
-    // Set working tree to match head.
-    repo.checkout_head(None)?;
-    Ok(())
-}
-
-fn do_merge<'a>(
-    repo: &'a Repository,
-    remote_branch: &str,
-    fetch_commit: AnnotatedCommit<'a>,
-) -> Result<Vec<FileDelta>, git2::Error> {
-    // 1. do a merge analysis
-    let analysis = repo.merge_analysis(&[&fetch_commit])?;
-
-    let head_commit = repo.reference_to_annotated_commit(&repo.head()?)?;
-
-    // 2. Do the appropriate merge
-    if analysis.0.is_fast_forward() {
-        // println!("Doing a fast-forward");
-        // do a 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(_) => {
-                // The branch doesn't exist, so set the reference to the
-                // commit directly. Usually this is because you are pulling
-                // into an empty repository.
-                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() {
-        // do a normal merge
-        normal_merge(repo, &head_commit, &fetch_commit)?;
-    }
-    // else {
-    //     // already up-to-date
-    //     println!("Nothing to do...");
-    // }
-
-    calculate_diff(repo, &head_commit, &fetch_commit)
-}
-
-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, _| {
-            // let delta = d.status();
-            //
-            // let n_path = d.new_file().path();
-            // let o_path = d.old_file().path();
-            //
-            // if let Some(path) = n_path {
-            //     updated_files.insert(path.to_owned());
-            // }
-            // if let Some(path) = o_path {
-            //     updated_files.insert(path.to_owned());
-            // }
-            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 // Continue
-        },
-        None,
-        None,
-        None,
-    ) {
-        error!("error at calculating diff: {:?}", e);
-    }
-
-    Ok(updated_files.into_iter().collect())
-}
-
-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/api_server/src/utils/mod.rs

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

backend/macros/src/log.rs

@@ -6,7 +6,7 @@
 /// use macros::panic_with_log;
 /// use tracing::Level;
 ///
-/// panic_with_log!(Level::ERROR, "Test panicked: {}", 42);
+/// panic_with_log!(Level::ERROR, "test panicked: {}", 42);
 /// ```
 #[macro_export]
 macro_rules! panic_with_log {
@@ -18,6 +18,25 @@ macro_rules! panic_with_log {
     }};
 }
 
+/// log the message with `Level::ERROR` and exit(1)
+///
+/// # Example
+/// ```rust
+///
+/// use macros::error_panic;
+///
+/// error_panic!("test panicked: {}", 42);
+/// ```
+#[macro_export]
+macro_rules! error_panic {
+    ($msg:literal $(, $($arg:tt)*)?) => {{
+        use std::process;
+        use tracing::{event, Level};
+        event!(Level::ERROR, $msg $(, $($arg)*)?);
+        process::exit(1);
+    }};
+}
+
 #[cfg(test)]
 mod tests {
     #[test]

backend/server/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "server"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+macros = { path = "../macros" }
+
+
+tracing = "0.1.41"
+git2 = "0.20.0"
+
+[build-dependencies]
+git2 = "0.20.0"
+chrono = "0.4.39"

backend/server/build.rs

@@ -0,0 +1,15 @@
+use chrono::Utc;
+use git2::Repository;
+
+fn main() {
+    let repo = Repository::open("../..").expect("failed to open repository");
+    let commit = repo
+        .head()
+        .expect("failed to get HEAD")
+        .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]);
+    println!("cargo:rustc-env=BUILD_ID={}", build_id);
+}

backend/server/schema.sql

@@ -0,0 +1,32 @@
+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/main.rs

@@ -0,0 +1,7 @@
+mod constants;
+
+const BUILD_ID: &str = env!("BUILD_ID");
+
+fn main() {
+    println!("{}", BUILD_ID);
+}

frontend/.dockerignore

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

frontend/.eslintignore

@@ -0,0 +1,38 @@
+**/*.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

@@ -0,0 +1,42 @@
+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

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

frontend/.gitignore

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

frontend/.prettierignore

@@ -0,0 +1,37 @@
+**/*.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

@@ -0,0 +1,65 @@
+# 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

@@ -1,21 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

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

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

@@ -1,37 +0,0 @@
-'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

@@ -1,43 +0,0 @@
-'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

@@ -1,21 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,21 +0,0 @@
-'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

@@ -1,104 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,13 +0,0 @@
-@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

@@ -1,29 +0,0 @@
-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

@@ -1,51 +0,0 @@
-'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

@@ -1,12 +0,0 @@
-'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

@@ -1,13 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,116 +0,0 @@
-'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

@@ -1,93 +0,0 @@
-'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

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

frontend/postcss.config.mjs

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

frontend/public/favicon.svg

@@ -0,0 +1 @@
+<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

@@ -0,0 +1,9 @@
+{
+  "$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

@@ -0,0 +1,4 @@
+// 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

@@ -1,18 +0,0 @@
-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

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

frontend/src/HomePageActivities/ghActivities/starRepo.tsx

@@ -1,34 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -0,0 +1,48 @@
+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

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

frontend/src/entry.dev.tsx

@@ -0,0 +1,17 @@
+/*
+ * 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

@@ -0,0 +1,21 @@
+/*
+ * 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

@@ -0,0 +1,33 @@
+/**
+ * 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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,17 @@
+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 />;
+});