ref(backend) start of refactor

backend/legacy/src/api/get/get_page_count.rs

@@ -0,0 +1,25 @@
+use crate::constants::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/legacy/src/api/get/get_post.rs

@@ -0,0 +1,154 @@
+use std::str::FromStr;
+
+use axum::{
+    extract::{Path, State},
+    http::StatusCode,
+    Json,
+};
+use serde_json::{json, Value};
+use sqlx::{Error, PgPool, query, Row};
+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/legacy/src/api/get/get_post_list.rs

@@ -0,0 +1,87 @@
+use crate::constants::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>,
+}
+
+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 = Map::new();
+    let posts: Vec<_> = post_list
+        .into_iter()
+        .map(|post| analyze_post(&db_connection, post))
+        .collect();
+
+    let posts = join_all(posts).await;
+
+    res.insert("posts".to_string(), Value::from(posts));
+    Ok(Json::from(Value::from(res)))
+}
+
+async fn analyze_post(db_connection: &PgPool, post: PgRow) -> Value {
+    let post_id: Uuid = post.get("post_id");
+    let tags = fetch_post_tags(db_connection, post_id).await;
+
+    json!({
+        "post_id": post_id.to_string(),
+        "title": post.get::<String, _>("title"),
+        "category": post.get::<String, _>("category"),
+        "header_img": post.get::<String, _>("header_img"),
+        "sub_title": post.get::<String, _>("sub_title"),
+        "summary": post.get::<String, _>("summary"),
+        "last_update": post.get::<DateTime<Utc>, _>("last_update"),
+        "first_update": post.get::<DateTime<Utc>, _>("first_update"),
+        "tags": tags,
+    })
+}
+
+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/legacy/src/api/get/mod.rs

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

backend/legacy/src/api/mod.rs

@@ -0,0 +1,2 @@
+pub mod get;
+pub mod post;

backend/legacy/src/api/post/errors/mod.rs

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

backend/legacy/src/api/post/errors/refresh.rs

@@ -0,0 +1,61 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum PostIdxError {
+    #[error("Failed to parse UUID <{}>: {}", id, err_msg)]
+    InvalidUUID { id: String, err_msg: String },
+
+    #[error(
+        "Failed to parse `last update time` for <{}> when creating post index: {}",
+        id,
+        err_msg
+    )]
+    InvalidLastUpdate { id: String, err_msg: String },
+
+    #[error(
+        "Failed to parse `first update time` for <{}> when creating post index: {}",
+        id,
+        err_msg
+    )]
+    InvalidFirstUpdate { id: String, err_msg: String },
+
+    #[error(
+        "Failed to parse `tag` for <{}> when creating post index: <{}>: {}",
+        id,
+        invalid_string,
+        err_msg
+    )]
+    InvalidTagString {
+        id: String,
+        invalid_string: String,
+        err_msg: String,
+    },
+
+    #[error(
+        "Database error on writing `{}` to table `{}`: <{}>: {}",
+        data_desc,
+        db_table,
+        id,
+        err_msg
+    )]
+    DBWriteFailure {
+        data_desc: String,
+        db_table: String,
+        id: String,
+        err_msg: String,
+    },
+
+    #[error(
+        "Database error on Reading `{}` from table `{}`: <{}>: {}",
+        data_desc,
+        db_table,
+        id,
+        err_msg
+    )]
+    DBReadFailure {
+        data_desc: String,
+        db_table: String,
+        id: String,
+        err_msg: String,
+    },
+}

backend/legacy/src/api/post/mod.rs

@@ -0,0 +1,3 @@
+mod errors;
+pub mod refresh;
+mod utils;

backend/legacy/src/api/post/refresh.rs

@@ -0,0 +1,192 @@
+use std::path::Path;
+use std::str::FromStr;
+use std::{env, fs};
+
+use axum::extract::{Query, State};
+use axum::http::StatusCode;
+use axum::Json;
+use futures::{stream, StreamExt};
+use serde::Deserialize;
+use serde_json::{json, Map, Value};
+use sha2::{Digest, Sha256};
+use sqlx::{query, PgPool};
+use tracing::error;
+use uuid::Uuid;
+
+use crate::api::post::errors::refresh::PostIdxError;
+use crate::api::post::utils::{build_post_idx, post};
+use crate::model::blog::{POST_BASE_MODEL, POST_HASH_MODEL, POST_META_MODEL, TAG_MODEL};
+
+#[derive(Deserialize)]
+pub struct Params {
+    /// refresh level
+    level: Option<String>,
+}
+
+pub async fn refresh(
+    State(db_connection): State<PgPool>,
+    Query(params): Query<Params>,
+) -> Result<StatusCode, (StatusCode, Json<Value>)> {
+    let is_force_refresh = params.level.unwrap_or("".to_string()) == "force";
+
+    // search post
+    let data_repo_dir = match env::var("GIT_WORK_DIR") {
+        Ok(value) => value,
+        Err(_) => {
+            return Err((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json::from(json!((
+                    "error",
+                    "error at parsing environment variable: GIT_WORK_DIR"
+                ))),
+            ));
+        }
+    };
+    let post_dir = Path::new(&data_repo_dir).join("posts");
+
+    if is_force_refresh {
+        if let Err(e) = query("DROP TABLE IF EXISTS hash, meta, post, tag;")
+            .execute(&db_connection)
+            .await
+        {
+            error!(
+                "DB query error when deleting table: `hash`, `meta`, `post`, `tag`: {}",
+                e.to_string()
+            );
+            return Err((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json::from(json!(("error", e.to_string()))),
+            ));
+        }
+    }
+
+    // generate post idx
+    let post_path = search_md(&post_dir);
+
+    let post_list_with_hash: Vec<(Map<_, _>, Vec<_>)> = post_path
+        .into_iter()
+        .filter_map(|post_path| match post::from_path(&post_path) {
+            Ok(post) => match fs::read(&post_path) {
+                Ok(bytes) => {
+                    let mut hasher = Sha256::new();
+                    hasher.update(bytes);
+                    let hash = hasher.finalize().to_vec();
+                    Some((post, hash))
+                }
+                Err(e) => {
+                    error!(
+                        "Failed to read file while hashing the post <{}>, skipping: {}",
+                        post_path,
+                        e.to_string()
+                    );
+                    None
+                }
+            },
+            Err(e) => {
+                error!(
+                    "Failed to parse post <{}>, skipping: {}",
+                    post_path,
+                    e.to_string()
+                );
+                None
+            }
+        })
+        .collect();
+
+    // db create
+    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();
+
+    let res: Vec<_> = stream::iter(post_list_with_hash)
+        .map(|(post, hash)| {
+            let db_clone = db_connection.clone();
+            async move { build_post_idx(&db_clone, post, hash).await }
+        })
+        .buffer_unordered(usize::MAX)
+        .collect()
+        .await;
+
+    let errs: Vec<_> = res
+        .into_iter()
+        .filter_map(|res| res.err())
+        .map(|e| e.to_string())
+        .collect();
+
+    if !errs.is_empty() {
+        Err((
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json::from(json!({"error": errs})),
+        ))
+    } else {
+        Ok(StatusCode::OK)
+    }
+}
+
+/// Search a dir, return a list of markdown files
+///
+/// # Arguments
+/// * `entry`: dir path
+///
+/// # Returns
+/// Vec<String, Global>
+/// * `String`: path of a markdown file
+///
+fn search_md(entry: &Path) -> Vec<String> {
+    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.as_path())
+                })
+                .collect()
+        } else {
+            vec![]
+        }
+    } else if entry.extension().is_some_and(|ext| ext == "md") {
+        vec![entry.to_str().unwrap().to_string()]
+    } else {
+        vec![]
+    }
+}
+
+async fn build_post_idx(
+    db_connection: &PgPool,
+    post: Map<String, Value>,
+    hash: Vec<u8>,
+) -> Result<(), PostIdxError> {
+    let meta = &post["meta"];
+
+    // extract post id
+    let post_id = match Uuid::from_str(post["post_id"].as_str().unwrap()) {
+        Ok(id) => id,
+        Err(e) => {
+            return Err(PostIdxError::InvalidUUID {
+                id: post["post_id"].as_str().unwrap().to_string(),
+                err_msg: e.to_string(),
+            })
+        }
+    };
+
+    if build_post_idx::hash(db_connection, post_id, hash).await? {
+        build_post_idx::base(db_connection, &post, post_id, meta).await?;
+        build_post_idx::tag(db_connection, post_id, meta).await?;
+        build_post_idx::meta(db_connection, post_id, meta).await?;
+    }
+
+    Ok(())
+}

backend/legacy/src/api/post/utils/build_post_idx.rs

@@ -0,0 +1,288 @@
+use base64::{Engine, engine::general_purpose};
+use chrono::DateTime;
+use serde_json::{Map, Value};
+use sqlx::{PgPool, query, Row};
+use uuid::Uuid;
+
+use crate::api::post::errors::refresh::PostIdxError;
+use crate::constants::GLOBAL_TIME_FORMAT;
+
+pub async fn base(
+    db_connection: &PgPool,
+    post: &Map<String, Value>,
+    post_id: Uuid,
+    meta: &Value,
+) -> Result<(), PostIdxError> {
+    let title = post["title"].as_str();
+    let summary = post
+        .get("summary")
+        .and_then(|summary| summary.as_str())
+        .unwrap_or("");
+    let content = post["content"].as_str();
+    let last_update =
+        match DateTime::parse_from_str(post["last_update"].as_str().unwrap(), GLOBAL_TIME_FORMAT) {
+            Ok(time) => time,
+            Err(e) => {
+                return Err(PostIdxError::InvalidLastUpdate {
+                    id: post_id.to_string(),
+                    err_msg: e.to_string(),
+                });
+            }
+        };
+    let first_update = match DateTime::parse_from_str(
+        post["first_update"].as_str().unwrap(),
+        GLOBAL_TIME_FORMAT,
+    ) {
+        Ok(time) => time,
+        Err(e) => {
+            return Err(PostIdxError::InvalidFirstUpdate {
+                id: post_id.to_string(),
+                err_msg: e.to_string(),
+            })
+        }
+    };
+    let sub_title = meta
+        .get("sub_title")
+        .and_then(|sub_title| sub_title.as_str())
+        .unwrap_or("");
+    let category = meta
+        .get("category")
+        .and_then(|category| category.as_str())
+        .unwrap_or("N/A");
+    let header_img = meta
+        .get("header_img")
+        .and_then(|header_img| header_img.as_str())
+        .unwrap_or("");
+
+    match query(
+        r##"
+INSERT INTO Post (post_id, title, summary, content, last_update, first_update, sub_title, category, header_img)
+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,
+    header_img = EXCLUDED.header_img;
+        "##,
+    )
+        .bind(post_id)
+        .bind(title)
+        .bind(summary)
+        .bind(content)
+        .bind(last_update)
+        .bind(first_update)
+        .bind(sub_title)
+        .bind(category)
+        .bind(header_img)
+        .execute(db_connection)
+        .await
+    {
+        Ok(_) => {}
+        Err(e) => {
+            return Err(
+                PostIdxError::DBWriteFailure {
+                    data_desc: "post base information".to_string(),
+                    db_table: "Post".to_string(),
+                    id: post_id.to_string(),
+                    err_msg: e.to_string()
+                }
+            )
+        }
+    }
+
+    Ok(())
+}
+
+pub async fn tag(db_connection: &PgPool, post_id: Uuid, meta: &Value) -> Result<(), PostIdxError> {
+    if let Some(tags_string) = meta.get("tags").to_owned() {
+        // parse tags string
+        let parsed: Value = match serde_json::from_str(tags_string.as_str().unwrap()) {
+            Ok(value) => value,
+            Err(e) => {
+                return Err(PostIdxError::InvalidTagString {
+                    id: post_id.to_string(),
+                    invalid_string: tags_string.to_string().to_string(),
+                    err_msg: e.to_string(),
+                })
+            }
+        };
+        let string_array = parsed.as_array().unwrap();
+        let tags: Vec<String> = string_array
+            .iter()
+            .map(|value| value.as_str().unwrap().to_string())
+            .collect();
+
+        // 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(),
+                err_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(),
+                        err_msg: e.to_string(),
+                    })
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// # Arguments
+///
+/// * `db_connection`: database connection
+/// * `post_id`: UUID of the post
+/// * `hash`: Hex String
+///
+/// # Returns
+/// Result<bool, PostIdxError>
+/// - `bool`: if the hash is different from database, return true, else false
+pub async fn hash(
+    db_connection: &PgPool,
+    post_id: Uuid,
+    hash: Vec<u8>,
+) -> Result<bool, PostIdxError> {
+    let base64_form = general_purpose::STANDARD.encode(hash);
+    match query("SELECT hash FROM Hash WHERE post_id = $1")
+        .bind(post_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_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_id.to_string(),
+                        err_msg: e.to_string(),
+                    });
+                }
+                Ok(true)
+            }
+        }
+        Err(e) => Err(PostIdxError::DBReadFailure {
+            data_desc: "post hash".to_string(),
+            db_table: "Hash".to_string(),
+            id: post_id.to_string(),
+            err_msg: e.to_string(),
+        }),
+    }
+}
+
+pub async fn meta(db_connection: &PgPool, post_id: Uuid, meta: &Value) -> Result<(), PostIdxError> {
+    let mut err_trails = 5;
+    loop {
+        if let Err(e) = query(
+            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_id.to_string().as_str(), meta.to_string()
+            ).as_str()
+        )
+            .execute(db_connection)
+            .await {
+            if err_trails >= 0 {
+                err_trails -= 1;
+                continue
+            } else {
+                return Err(PostIdxError::DBWriteFailure {
+                    data_desc: "post meta data".to_string(),
+                    db_table: "Meta".to_string(),
+                    id: post_id.to_string(),
+                    err_msg: e.to_string(),
+                })
+            }
+        } else {
+            return Ok(())
+        }
+    }
+}

backend/legacy/src/api/post/utils/mod.rs

@@ -0,0 +1,2 @@
+pub mod build_post_idx;
+pub mod post;

backend/legacy/src/api/post/utils/post.rs

@@ -0,0 +1,120 @@
+use std::{env, fs};
+use std::error::Error;
+use std::process::Command;
+use std::str;
+use std::str::FromStr;
+
+use chrono::{DateTime, Utc};
+use serde_json::{Map, Value};
+use tracing::{error, warn};
+use uuid::Uuid;
+
+use crate::constants::GLOBAL_TIME_FORMAT;
+use crate::markdown::meta::parse_meta;
+
+pub fn from_path(path: &str) -> Result<Map<String, Value>, Box<dyn Error>> {
+    let mut res = Map::new();
+
+    // field `content`
+    let md_content = fs::read_to_string(path)?;
+    res.insert("content".to_string(), Value::from(md_content.to_owned()));
+
+    // field `meta`
+    let meta = parse_meta(&md_content);
+    let meta_map: Map<String, Value> = meta
+        .clone()
+        .into_iter()
+        .map(|(k, v)| (k, Value::from(v)))
+        .collect();
+    res.insert("meta".to_string(), Value::from(meta_map));
+
+    // field `post_id`
+    let post_id = match meta.get("id") {
+        None => Uuid::new_v4(),
+        Some(id) => match Uuid::from_str(id.as_str()) {
+            Ok(id) => id,
+            Err(e) => {
+                error!("Failed to parse UUID <{}>: {}", id.as_str(), e.to_string());
+                return Err(Box::new(e));
+            }
+        },
+    };
+    res.insert("post_id".to_string(), Value::from(post_id.to_string()));
+
+    // field `title`
+    let title = match meta.get("title") {
+        None => "Title Not Found".to_string(),
+        Some(title) => title.to_owned(),
+    };
+    res.insert("title".to_string(), Value::from(title));
+
+    // field `summary`
+    let summary = match meta.get("summary") {
+        None => "".to_string(),
+        Some(summary) => summary.to_owned(),
+    };
+    res.insert("summary".to_string(), Value::from(summary));
+
+    // field `last_update`
+    let git_output = match Command::new("git")
+        .arg("--no-pager")
+        .arg("log")
+        .arg("-1")
+        .arg("--format=%cI")
+        .arg("--")
+        .current_dir(env::var("GIT_WORK_DIR")?)
+        .arg(path)
+        .output()
+    {
+        Ok(res) => res,
+        Err(e) => {
+            error!("Failed to execute `git` command: {}", e.to_string());
+            return Err(Box::new(e));
+        }
+    };
+    let last_update: DateTime<Utc> = if git_output.status.success() {
+        chrono::DateTime::parse_from_str(
+            str::from_utf8(&git_output.stdout).unwrap().trim_end(),
+            GLOBAL_TIME_FORMAT,
+        )
+        .unwrap_or_else(|_| DateTime::from(Utc::now()))
+        .to_utc()
+    } else {
+        Utc::now().to_utc()
+    };
+    res.insert(
+        "last_update".to_string(),
+        Value::from(last_update.format(GLOBAL_TIME_FORMAT).to_string()),
+    );
+
+    // field `first_update`
+    let first_update: DateTime<Utc> = match meta.get("date") {
+        None => {
+            warn!(
+                "Failed to parse first update time for post {}, using current time instead",
+                post_id.to_string()
+            );
+            Utc::now().to_utc()
+        }
+        Some(date) => DateTime::from(
+            match DateTime::parse_from_str(format!("{}T000000", date).as_str(), "%Y-%m-%d%zT%H%M%S")
+            {
+                Ok(time) => time,
+                Err(e) => {
+                    warn!(
+                        "Failed to parse first update time for post {}, using current time instead: {}",
+                        post_id.to_string(),
+                        e.to_string()
+                    );
+                    DateTime::from(Utc::now())
+                }
+            },
+        ),
+    };
+    res.insert(
+        "first_update".to_string(),
+        Value::from(first_update.format(GLOBAL_TIME_FORMAT).to_string()),
+    );
+
+    Ok(res)
+}

backend/legacy/src/constants.rs

@@ -0,0 +1,3 @@
+pub const GLOBAL_TIME_FORMAT: &str = "%Y-%m-%dT%H:%M:%S%z";
+
+pub const PAGE_SIZE: u32 = 6;

backend/legacy/src/logger.rs

@@ -0,0 +1,67 @@
+use std::{env, io};
+
+use chrono::Local;
+use tracing::info;
+use tracing_appender::{non_blocking, rolling};
+use tracing_appender::non_blocking::WorkerGuard;
+use tracing_subscriber::{fmt, Registry};
+use tracing_subscriber::fmt::format::Writer;
+use tracing_subscriber::fmt::MakeWriter;
+use tracing_subscriber::fmt::time::FormatTime;
+use tracing_subscriber::layer::SubscriberExt;
+
+use crate::constants::GLOBAL_TIME_FORMAT;
+
+struct LocalTimer;
+
+impl FormatTime for LocalTimer {
+    fn format_time(&self, w: &mut Writer<'_>) -> std::fmt::Result {
+        write!(w, "{}", Local::now().format(GLOBAL_TIME_FORMAT))
+    }
+}
+
+type _LogWriter = dyn for<'writer> MakeWriter<'writer, Writer = dyn io::Write + 'static> + 'static;
+
+pub fn init() -> (WorkerGuard, WorkerGuard) {
+    let log_path = env::var("LOG_ROOT_DIR").unwrap_or_else(|e| {
+        panic!("[Fatal] failed to load LOG_ROOT_DIR: {}", e);
+    });
+
+    let log_path = format!("{}/backend", log_path);
+
+    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 log_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)
+                .with_ansi(false),
+        )
+        .with(
+            fmt::Layer::default()
+                .with_writer(err_log_writer)
+                .with_ansi(false),
+        )
+        .with(
+            fmt::Layer::default()
+                .with_writer(io::stdout)
+                .with_ansi(true)
+                .event_format(log_format),
+        );
+
+    tracing::subscriber::set_global_default(subscribers)
+        .expect("[Fatal] Failed to setup logging system");
+
+    info!("Module Started: Logger");
+
+    // error!("test");
+    (info_guard, error_guard)
+}

backend/legacy/src/main.rs

@@ -0,0 +1,95 @@
+use std::env;
+use std::error::Error;
+use std::num::ParseIntError;
+use std::process::exit;
+use std::str::FromStr;
+
+use crate::api::{
+    get::{get_page_count::get_page_count, get_post::get_post, get_post_list::get_post_list},
+    post::refresh::refresh,
+};
+use axum::routing::{get, post};
+use axum::Router;
+use sqlx::postgres::{PgConnectOptions, PgPoolOptions};
+use sqlx::ConnectOptions;
+use tracing::{error, info, warn};
+
+mod api;
+mod constants;
+mod logger;
+mod markdown;
+mod model;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    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")
+    }
+
+    let _guards = logger::init();
+
+    let port: u32 = match env::var("BACKEND_PORT") {
+        Ok(value) => value.parse().unwrap_or_else(|e: ParseIntError| {
+            warn!("Failed to parse BACKEND_PORT: {}", e.to_string());
+            3001
+        }),
+        Err(_) => 3001,
+    };
+
+    let db_connect_option = PgConnectOptions::from_str(&parse_db_uri())
+        .unwrap()
+        .disable_statement_logging();
+
+    let db_pool = match PgPoolOptions::new().connect_with(db_connect_option).await {
+        Ok(pool) => {
+            info!("Database connected");
+            pool
+        }
+        Err(e) => {
+            error!("Failed to load database: {}", e.to_string());
+            exit(1);
+        }
+    };
+
+    let app = Router::new()
+        .route("/refresh_posts", post(refresh))
+        .route("/get_post_list", get(get_post_list))
+        .route("/get_page_count", get(get_page_count))
+        .route("/get_post/:post_id", get(get_post))
+        .with_state(db_pool);
+
+    let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", port))
+        .await
+        .unwrap_or_else(|e| {
+            error!("Failed to build TCP listener: {}", e.to_string());
+            exit(1);
+        });
+
+    axum::serve(listener, app).await.unwrap_or_else(|e| {
+        error!("Failed to start axum: {}", e.to_string());
+        exit(1);
+    });
+
+    Ok(())
+}
+
+fn parse_db_uri() -> String {
+    let postgres_user = env::var("POSTGRES_USER").unwrap_or("".to_string());
+    let postgres_password = env::var("POSTGRES_PASSWORD").unwrap_or("".to_string());
+    let db_host = env::var("DB_HOST").unwrap_or("localhost".to_string());
+    let db_port = env::var("DB_PORT")
+        .unwrap_or("5432".to_string())
+        .to_string();
+    let postgres_db = env::var("POSTGRES_DB").unwrap_or("nocturne".to_string());
+
+    format!("postgresql://{postgres_user}:{postgres_password}@{db_host}:{db_port}/{postgres_db}")
+}

backend/legacy/src/markdown/meta.rs

@@ -0,0 +1,55 @@
+use std::collections::HashMap;
+
+use regex::Regex;
+
+/// return the meta info contained in the .md file front matter
+pub fn parse_meta(md_content: &str) -> HashMap<String, String> {
+    let mut fields: HashMap<String, String> = HashMap::new();
+    let match_regex = Regex::new(r"(?s)---\n(.*\n)---\n").unwrap();
+    if let Some(front_matter) = match_regex.captures(md_content) {
+        let fm_content = front_matter.get(1).unwrap().as_str();
+        for line in fm_content.lines() {
+            if let Some((k, v)) = extract_kv(line) {
+                fields.insert(k, v);
+            }
+        }
+    }
+    fields
+}
+
+fn extract_kv(line: &str) -> Option<(String, String)> {
+    let split: Vec<&str> = line.splitn(2, ':').map(|s| s.trim()).collect();
+    if split.len() == 2 {
+        let key = split[0].to_string();
+        let value = split[1].to_string();
+        Some((key, value))
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+mod meta_test {
+    use std::error::Error;
+
+    use crate::markdown::meta::parse_meta;
+
+    #[test]
+    fn test_parse_meta_front_matter() -> Result<(), Box<dyn Error>> {
+        let parsed_meta = parse_meta(
+            r##"
+---
+title: Hello World!
+tags: [ "test", "hello_world" ]
+---
+            "##,
+        );
+        dbg!(&parsed_meta);
+        assert_eq!(parsed_meta.get("title"), Some(&"Hello World!".to_string()));
+        assert_eq!(
+            parsed_meta.get("tags"),
+            Some(&r#"[ "test", "hello_world" ]"#.to_string())
+        );
+        Ok(())
+    }
+}

backend/legacy/src/markdown/mod.rs

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

backend/legacy/src/model/blog/hash.sql

@@ -0,0 +1,5 @@
+CREATE TABLE IF NOT EXISTS Hash
+(
+    post_id UUID PRIMARY KEY,
+    hash    VARCHAR(44)
+);

backend/legacy/src/model/blog/meta.sql

@@ -0,0 +1,79 @@
+CREATE TABLE IF NOT EXISTS Meta
+(
+    post_id UUID PRIMARY KEY
+);
+
+DROP table meta;
+
+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 ['id', '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;
+
+SELECT jsonb_strip_nulls(to_jsonb(t)) AS meta
+FROM meta t
+WHERE post_id = '8ca3fa2b-f040-448c-8885-81aab56db9bb';
+
+WITH target_post AS (SELECT t.date FROM meta t WHERE post_id = '8ca3fa2b-f040-448c-8885-81aab56db9bb'),
+     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;
+

backend/legacy/src/model/blog/mod.rs

@@ -0,0 +1,38 @@
+pub 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,
+    header_img   TEXT,
+    summary      TEXT,
+    sub_title    TEXT,
+    content      TEXT         NOT NULL,
+    last_update  TIMESTAMPTZ  NOT NULL,
+    first_update TIMESTAMPTZ  NOT NULL
+);
+"##;
+
+// base mode, will add more cols in runtime
+pub const POST_META_MODEL: &str = r##"
+CREATE TABLE IF NOT EXISTS Meta
+(
+    post_id      UUID PRIMARY KEY
+);
+"##;
+
+pub const POST_HASH_MODEL: &str = r##"
+CREATE TABLE IF NOT EXISTS Hash
+(
+    post_id      UUID PRIMARY KEY,
+    hash         VARCHAR(44)
+);
+"##;
+
+pub const TAG_MODEL: &str = r##"
+CREATE TABLE IF NOT EXISTS Tag
+(
+    post_id UUID         NOT NULL,
+    tag     VARCHAR(255) NOT NULL
+);
+"##;

backend/legacy/src/model/blog/post.sql

@@ -0,0 +1,12 @@
+CREATE TABLE IF NOT EXISTS Post
+(
+    post_id      UUID PRIMARY KEY,
+    title        VARCHAR(255) NOT NULL,
+    category     VARCHAR(255) NOT NULL,
+    header_img   TEXT,
+    summary      TEXT,
+    sub_title    TEXT,
+    content      TEXT         NOT NULL,
+    last_update  TIMESTAMPTZ  NOT NULL,
+    first_update TIMESTAMPTZ  NOT NULL
+);

backend/legacy/src/model/blog/tag.sql

@@ -0,0 +1,5 @@
+CREATE TABLE IF NOT EXISTS Tag
+(
+    post_id UUID         NOT NULL,
+    tag     VARCHAR(255) NOT NULL
+);

backend/legacy/src/model/mod.rs

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