feat(frontend) qwik init

.env

@@ -17,7 +17,3 @@ WORK_DIR=/nocturne
 # frontend settings
 API_LOCAL_URL=http://backend:3001
 API_REMOTE_URL=https://lumither.com/api
-
-# deployment
-USE_CR=true
-CHANNEL=release

.github/workflows/canary-build.yml

@@ -1,64 +0,0 @@
-name: build canary nocturne image
-on:
-  push:
-    branches:
-      - master
-
-env:
-  REGISTRY: cr.lmt.moe
-  TAG: canary
-  PROJECT: nocturne
-
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: checkout
-        uses: actions/checkout@v4
-
-      - name: setup builder
-        uses: docker/setup-buildx-action@v3
-
-      - name: registry login
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ secrets.REGISTRY_USERNAME }}
-          password: ${{ secrets.REGISTRY_PASSWORD }}
-
-      - name: build containers
-        run: |
-          make build
-
-      - name: tag and push
-        run: |
-          PROJECT_NAME=$(basename "$PWD")
-
-          ALL_IMAGES=$(docker compose -f prod.compose.yaml config --services 2>/dev/null)
-          PULLED_IMAGES=$(docker compose -f prod.compose.yaml config 2>/dev/null \
-                          | awk '/image:/ {print $2}' \
-                          | sort -u \
-                          | sed 's/:.*//' \
-          )
-          TO_PUSH=$(comm -23 \
-            <(echo "$ALL_IMAGES" | sort) \
-            <(echo "$PULLED_IMAGES") \
-          )
-          
-          FMT_STRING=$(echo "$TO_PUSH" | xargs printf '%s, ' | sed 's/, $//')
-          echo "services to push: $FMT_STRING"
-          
-          for SERVICE in $TO_PUSH; do
-            LOCAL_TAG="${PROJECT_NAME}-${SERVICE}:latest"
-            REMOTE_TAG="${REGISTRY}/${PROJECT}/${SERVICE}:${TAG}"
-          
-            if docker image inspect "$LOCAL_TAG" >/dev/null 2>&1; then
-              echo "Pushing $REMOTE_TAG"
-              docker tag "$LOCAL_TAG" "$REMOTE_TAG"
-              docker push "$REMOTE_TAG"
-            else
-              echo "warn: image $LOCAL_TAG not found, skipping $SERVICE"
-            fi
-          
-          done

.github/workflows/release-build.yml

@@ -1,64 +0,0 @@
-name: build release nocturne image
-on:
-  push:
-    branches:
-      - release
-
-env:
-  REGISTRY: cr.lmt.moe
-  TAG: release
-  PROJECT: nocturne
-
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: checkout
-        uses: actions/checkout@v4
-
-      - name: setup builder
-        uses: docker/setup-buildx-action@v3
-
-      - name: registry login
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ secrets.REGISTRY_USERNAME }}
-          password: ${{ secrets.REGISTRY_PASSWORD }}
-
-      - name: build containers
-        run: |
-          make build
-
-      - name: tag and push
-        run: |
-          PROJECT_NAME=$(basename "$PWD")
-
-          ALL_IMAGES=$(docker compose -f prod.compose.yaml config --services 2>/dev/null)
-          PULLED_IMAGES=$(docker compose -f prod.compose.yaml config 2>/dev/null \
-                          | awk '/image:/ {print $2}' \
-                          | sort -u \
-                          | sed 's/:.*//' \
-          )
-          TO_PUSH=$(comm -23 \
-            <(echo "$ALL_IMAGES" | sort) \
-            <(echo "$PULLED_IMAGES") \
-          )
-          
-          FMT_STRING=$(echo "$TO_PUSH" | xargs printf '%s, ' | sed 's/, $//')
-          echo "services to push: $FMT_STRING"
-          
-          for SERVICE in $TO_PUSH; do
-            LOCAL_TAG="${PROJECT_NAME}-${SERVICE}:latest"
-            REMOTE_TAG="${REGISTRY}/${PROJECT}/${SERVICE}:${TAG}"
-          
-            if docker image inspect "$LOCAL_TAG" >/dev/null 2>&1; then
-              echo "Pushing $REMOTE_TAG"
-              docker tag "$LOCAL_TAG" "$REMOTE_TAG"
-              docker push "$REMOTE_TAG"
-            else
-              echo "warn: image $LOCAL_TAG not found, skipping $SERVICE"
-            fi
-          
-          done

.gitignore

@@ -6,12 +6,5 @@
 .idea
 .vscode
 
-# macOS system files
+# exclude post repo
-.DS_Store
-**/.DS_Store
-
-# exclude content repo
 /blog_posts_git
-
-# rustc ICE dump
-rustc-ice-*.txt

Makefile

@@ -3,42 +3,14 @@ ifeq ($(ARCH), arm64)
     ARCH := aarch64
 endif
 
-ifneq (,$(wildcard ./.env))
+all: release
-    include ./.env
-    export
-endif
-ifneq (,$(wildcard ./.env.local))
-    include ./.env.local
-    export
-endif
 
-USE_CR ?= false
+release:
-CHANNEL ?= release
+	docker compose -f prod.compose.yaml build --build-arg ARCH=$(ARCH)
-ifeq ($(USE_CR), true)
-    COMPOSE_FILE := prod.cr.compose.yaml
-else
-    COMPOSE_FILE := prod.compose.yaml
-endif
 
-DOCKER_ENV := ARCH=$(ARCH) TAG=$(CHANNEL)
+dev:
-DOCKER_COMPOSE := $(DOCKER_ENV) docker compose -f $(COMPOSE_FILE)
+	docker-compose -f dev.compose.yaml up --build
 
-.PHONY: all
-all:up
-
-.PHONY: build
-build:
-	$(DOCKER_COMPOSE) pull
-	$(DOCKER_COMPOSE) build
-
-.PHONY: up
-up:
-	$(DOCKER_COMPOSE) up -d
-
-.PHONY: down
-down:
-	$(DOCKER_COMPOSE) down
-
-.PHONY: clean
 clean:
-	$(DOCKER_COMPOSE) down --rmi all --volumes
+	docker-compose -f prod.compose.yaml -f dev.compose.yaml rm -fsv
+

README.md

@@ -7,4 +7,10 @@ content (blog posts etc.) repo.
 Powered by Next.js and Rust, built with passion and love
 
 > [!NOTE]
-> This is an unstable branch, checkout `release` for the (guaranteed) working version
+> This system is not production ready, and contains bugs, (security risk potentially).
+> But have fun on it =)
+
+# Todos
+
+- [ ] the todo list lol
+- [ ] and much more...

backend/Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-resolver = "3"
+resolver = "2"
 members = [
     "server",
     "macros",

backend/macros/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "macros"
 version = "0.1.0"
-edition = "2024"
+edition = "2021"
 
 [dependencies]
 tracing = "0.1.40"

backend/macros/src/dev.rs

@@ -1,6 +0,0 @@
-#[macro_export]
-macro_rules! dev_consume {
-    ($($var:ident),+) => {
-        $(let _ = $var;)*
-    };
-}

backend/macros/src/include_str.rs

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

backend/macros/src/lib.rs

@@ -1,3 +1 @@
-mod dev;
-mod include_str;
 mod log;

backend/macros/src/log.rs

@@ -44,7 +44,7 @@ mod tests {
         use std::io;
         use tracing::Level;
         use tracing_subscriber::prelude::*;
-        use tracing_subscriber::{Registry, fmt};
+        use tracing_subscriber::{fmt, Registry};
 
         let format = tracing_subscriber::fmt::format()
             .with_level(true)

backend/markdown/Cargo.toml

@@ -1,14 +1,14 @@
 [package]
 name = "markdown"
 version = "0.1.0"
-edition = "2024"
+edition = "2021"
 
 [dependencies]
 uuid = { version = "1.10.0", features = ["v4", "fast-rng", "serde"] }
 serde = { version = "1.0.209", features = ["derive"] }
 serde_json = "1.0.128"
 regex = "1.10.4"
-yaml-rust2 = "0.10.0"
+yaml-rust2 = "0.9.0"
 sha2 = "0.10.8"
 base64 = "0.22.1"
 thiserror = "2.0.3"

backend/markdown/src/error.rs

@@ -2,6 +2,12 @@ use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum Error {
+    #[error("missing front-matter field: id")]
+    MissingID,
+
+    #[error("invalid file id: {}", msg)]
+    InvalidID { msg: String },
+
     #[error("invalid front-matter: {}", msg)]
     InvalidFrontMatter { msg: String },
 

backend/markdown/src/lib.rs

@@ -1,20 +1,23 @@
-pub mod error;
+mod error;
 mod utils;
 
-use std::{fs, path::Path, str::FromStr};
+use std::fs;
+use std::path::Path;
+use std::str::FromStr;
 
-use crate::{
+use crate::error::Error;
-    error::Error,
+use crate::utils::front_matter::{parse_front_matter, split_md_front_matter};
-    utils::front_matter::{parse_front_matter, split_md_front_matter},
-};
 
-use base64::{Engine, engine::general_purpose};
+use base64::{engine::general_purpose, Engine};
 use serde::Serialize;
 use serde_json::Value;
 use sha2::{Digest, Sha256};
+use uuid::Uuid;
 
-#[derive(Default, Debug, Serialize, Clone)]
+#[derive(Default, Debug, Serialize)]
 pub struct MdFile {
+    pub file_id: Uuid,
+    pub filename: String,
     pub meta: Value,
     pub content: String,
     pub hash: String,
@@ -26,22 +29,30 @@ impl MdFile {
             Ok(file) => file,
             Err(e) => return Err(Error::FSError { msg: e.to_string() }),
         };
-        Self::from_str(&raw_file)
+        let raw_file_bytes = raw_file.as_bytes().to_vec();
-    }
+        let (front_matter_str, content) = split_md_front_matter(raw_file);
-}
-
-impl FromStr for MdFile {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let bytes = s.as_bytes().to_vec();
-        let (front_matter_str, content) = split_md_front_matter(s);
         let front_matter = match parse_front_matter(&front_matter_str) {
             Ok(front_matter) => front_matter,
             Err(e) => return Err(Error::InvalidFrontMatter { msg: e.to_string() }),
         };
-        let hash = calculate_hash_base64(&bytes);
+        let hash = calculate_hash_base64(&raw_file_bytes);
+        let file_id = match front_matter["id"].as_str() {
+            Some(id) => match Uuid::from_str(id) {
+                Ok(id) => id,
+                Err(e) => return Err(Error::InvalidID { msg: e.to_string() }),
+            },
+            None => return Err(Error::MissingID),
+        };
+        let file_name = Path::new(file_path)
+            .file_name()
+            .unwrap()
+            .to_str()
+            .unwrap()
+            .to_string();
+
         Ok(MdFile {
+            file_id,
+            filename: file_name,
             meta: front_matter,
             content,
             hash,

backend/markdown/src/utils/front_matter.rs

@@ -1,19 +1,17 @@
-use std::error::Error;
-
 use crate::utils::yaml::yaml_to_serde;
-
 use regex::Regex;
 use serde_json::Value;
+use std::error::Error;
 use yaml_rust2::YamlLoader;
 
-pub fn split_md_front_matter(raw_file: &str) -> (String, String) {
+pub fn split_md_front_matter(raw_file: String) -> (String, String) {
     let re = Regex::new(r"(?s)^(---\n.*?\n---\n)(.*)").unwrap();
-    if let Some(captures) = re.captures(raw_file) {
+    if let Some(captures) = re.captures(raw_file.as_str()) {
         let front_matter = captures.get(1).map_or("", |m| m.as_str()).to_string();
         let main_content = captures.get(2).map_or("", |m| m.as_str()).to_string();
         (front_matter, main_content)
     } else {
-        (String::new(), raw_file.to_string())
+        (String::new(), raw_file)
     }
 }
 
@@ -45,7 +43,8 @@ tags: [ "test1", "test2" ]
 
 test body
 
-"##,
+"##
+            .to_string(),
         );
         assert_eq!(
             front_matter,
@@ -65,7 +64,7 @@ tags: [ "test1", "test2" ]
 
     #[test]
     fn test_front_matter_parser() {
-        parse_front_matter(
+        dbg!(parse_front_matter(
             r##"---
 title: test_title
 date: 0000-00-00+0000
@@ -76,7 +75,7 @@ summary: summary
 tags: [ "test1", "test2" ]
 ---
 "##,
-        )
+        ))
         .expect("Failed to parse front matter");
     }
 }

backend/server/Cargo.toml

@@ -1,33 +1,14 @@
 [package]
 name = "server"
 version = "0.1.0"
-edition = "2024"
+edition = "2021"
 
 [dependencies]
 macros = { path = "../macros" }
-markdown = { path = "../markdown" }
 
-axum = { version = "0.8.1", features = ["macros"] }
+
-axum-extra = { version = "0.10.3", features = ["query"] }
+tracing = "0.1.41"
-tracing = { version = "0.1.41", features = ["log"] }
 git2 = "0.20.0"
-chrono = { version = "0.4.39", features = ["serde"] }
-cron = "0.15.0"
-sqlx = { version = "0.8.3", features = ["runtime-tokio", "tls-native-tls", "postgres", "chrono", "uuid"] }
-serde_json = "1.0.133"
-serde = { version = "1.0.215", features = ["derive"] }
-tracing-subscriber = "0.3.18"
-tracing-appender = "0.2.3"
-dirs = "6.0.0"
-thiserror = "2.0.11"
-tokio = { version = "1.42.0", features = ["rt", "rt-multi-thread", "macros", "sync"] }
-regex = "1.11.1"
-dotenv = "0.15.0"
-uuid = { version = "1.13.2", features = ["v4"] }
-futures = "0.3.31"
-
-[dev-dependencies]
-tempfile = "3.19.1"
 
 [build-dependencies]
 git2 = "0.20.0"

backend/server/build.rs

@@ -1,17 +1,15 @@
-// use chrono::Utc;
+use chrono::Utc;
-// use git2::Repository;
+use git2::Repository;
 
 fn main() {
-    // let repo = Repository::open("../..").expect("failed to open repository");
+    let repo = Repository::open("../..").expect("failed to open repository");
-    // let commit = repo
+    let commit = repo
-    //     .head()
+        .head()
-    //     .expect("failed to get HEAD")
+        .expect("failed to get HEAD")
-    //     .peel_to_commit()
+        .peel_to_commit()
-    //     .expect("failed to get HEAD commit");
+        .expect("failed to get HEAD commit");
-    // let hash = commit.id().to_string();
+    let hash = commit.id().to_string();
-    // let utc_timestamp = Utc::now().date_naive().format("%Y%m%d").to_string();
+    let utc_date = Utc::now().date_naive().format("%Y%m%d").to_string();
-    // let pkg_version = env!("CARGO_PKG_VERSION");
+    let build_id = format!("{}@{}", utc_date, &hash[..8]);
-    // let build_id = format!("{}:{}@{}", pkg_version, &hash[..8], utc_timestamp);
+    println!("cargo:rustc-env=BUILD_ID={}", build_id);
-    // println!("cargo:rustc-env=BUILD_ID={}", build_id);
-    println!("cargo:rustc-env=BUILD_ID=undefined");
 }

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/constants/config.rs

@@ -1,5 +1,3 @@
-// todo: rebuild with static OnceCell
-
 // Database related
 pub mod database {
     pub mod var_name {

backend/server/src/constants/time.rs

@@ -1,3 +1,2 @@
 pub const DEFAULT_TIME_FORMAT: &str = "%Y-%m-%dT%H:%M:%S%z";
-
+pub const DEFAULT_DATE_FORMAT: &str = "%Y-%m-%d%zT%H%M%S";
-pub const DEFAULT_NAIVE_DATE_FORMAT: &str = "%Y-%m-%d";

backend/server/src/init/database.rs

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

backend/server/src/init/logger.rs

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

backend/server/src/init/misc.rs

@@ -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/server/src/init/mod.rs

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

backend/server/src/main.rs

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

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

@@ -1,3 +0,0 @@
-// todo: remove exception tag
-#[allow(dead_code)]
-pub mod posts;

backend/server/src/modules/blog/api/posts/count_tag_filtered_posts.sql

@@ -1,20 +0,0 @@
-WITH filtered_posts AS
-         (SELECT p.id, p.date_created
-          FROM posts p
-          WHERE $1::text[] IS NULL
-             OR (
-              CASE
-                  WHEN $4 THEN (SELECT COUNT(DISTINCT t.name)
-                                FROM post_tag pt
-                                         JOIN tags t ON pt.tag = t.id
-                                WHERE pt.post = p.id
-                                  AND t.name = ANY ($1::text[])) = cardinality($1)
-                  ELSE EXISTS (SELECT 1
-                               FROM post_tag pt
-                                        JOIN tags t ON pt.tag = t.id
-                               WHERE pt.post = p.id
-                                 AND t.name = ANY ($1::text[]))
-                  END
-              ))
-SELECT COUNT(*) AS total_count
-FROM filtered_posts;

backend/server/src/modules/blog/api/posts/get.rs

@@ -1,174 +0,0 @@
-use crate::{
-    constants::blog::PAGE_SIZE,
-    err_resp_log,
-    utils::axum_response::{err_resp, succ_resp},
-};
-
-use std::collections::HashSet;
-
-use axum::{extract::State, http::StatusCode, response::IntoResponse};
-use axum_extra::extract::Query;
-use chrono::NaiveDate;
-use serde::{Deserialize, Serialize};
-use serde_json::json;
-use sqlx::{query_as, FromRow, PgPool};
-use uuid::Uuid;
-
-fn tags_deserializer<'de, D>(deserializer: D) -> Result<Option<Vec<String>>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    let deserialize_each = |input: String| -> Result<Vec<String>, D::Error> {
-        Ok(input.split(',').map(|s| s.to_string()).collect())
-    };
-
-    #[derive(Deserialize)]
-    #[serde(untagged)]
-    enum Cardinality {
-        One(String),
-        Many(Vec<String>),
-    }
-    let cardinality: Option<Cardinality> = Deserialize::deserialize(deserializer)?;
-
-    let mut tags = HashSet::new();
-
-    match cardinality {
-        Some(Cardinality::One(s)) => {
-            for item in deserialize_each(s)? {
-                let item = item.trim().to_string();
-                if !item.is_empty() {
-                    tags.insert(item);
-                }
-            }
-            let ret = tags.into_iter().collect::<Vec<_>>();
-            Ok(if ret.is_empty() { None } else { Some(ret) })
-        }
-        Some(Cardinality::Many(v)) => {
-            for items in v
-                .into_iter()
-                .map(deserialize_each)
-                .collect::<Result<Vec<_>, _>>()?
-            {
-                for item in items {
-                    let item = item.trim().to_string();
-                    if !item.is_empty() {
-                        tags.insert(item);
-                    }
-                }
-            }
-            let ret = tags.into_iter().collect::<Vec<_>>();
-            Ok(if ret.is_empty() { None } else { Some(ret) })
-        }
-        None => Ok(None),
-    }
-}
-
-#[derive(FromRow, Serialize)]
-struct PostBriefModel {
-    id: Uuid,
-    identifier: String,
-    title: String,
-    subtitle: String,
-    tags: Vec<String>,
-    category: String,
-    date_created: NaiveDate,
-    date_updated: Option<NaiveDate>,
-    header_img: Option<String>,
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct SearchParams {
-    page: Option<u32>,
-    page_size: Option<u32>,
-
-    #[serde(default, deserialize_with = "tags_deserializer")]
-    tags: Option<Vec<String>>,
-
-    #[serde(default)]
-    match_all: bool,
-}
-
-#[derive(Serialize)]
-pub struct RespPagination {
-    page: u32,
-    page_size: u32,
-    page_count: u32,
-}
-
-#[derive(Serialize)]
-struct Response {
-    posts: Vec<PostBriefModel>,
-    pagination: RespPagination,
-}
-
-#[derive(FromRow)]
-struct UuidRow {
-    id: Uuid,
-}
-
-const I32_PLACEHOLDER: i32 = 0;
-
-const COUNT_TAG_FILTERED_POSTS: &str = include_str!("count_tag_filtered_posts.sql");
-const SELECT_POST_WITH_TAG_FILTER_PAGINATED: &str =
-    include_str!("select_post_with_tag_filter_paginated.sql");
-const GET_POST_WITH_BRIEF_MODEL: &str = include_str!("get_post_with_brief_model.sql");
-
-pub async fn handler(
-    State(db): State<PgPool>,
-    Query(search_params): Query<SearchParams>,
-) -> impl IntoResponse {
-    let page = search_params.page.unwrap_or(1);
-    let page_size = search_params.page_size.unwrap_or(PAGE_SIZE);
-
-    let page_count = match sqlx::query_scalar::<_, i64>(COUNT_TAG_FILTERED_POSTS)
-        .bind(&search_params.tags)
-        .bind(I32_PLACEHOLDER) // not used, but help sqlx/psql hit cache
-        .bind(I32_PLACEHOLDER)
-        .bind(search_params.match_all)
-        .fetch_one(&db)
-        .await
-    {
-        Ok(post_count) => ((post_count as f64) / (page_size as f64)).ceil() as u32,
-        Err(e) => return err_resp_log!(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
-    };
-
-    let pagination = RespPagination {
-        page,
-        page_size,
-        page_count,
-    };
-
-    if page > page_count {
-        return err_resp(
-            StatusCode::BAD_REQUEST,
-            "page number should not be greater than page count",
-            Some(json!({"pagination": pagination})),
-        );
-    }
-
-    let offset = page_size * (page - 1);
-
-    let ids = match query_as::<_, UuidRow>(SELECT_POST_WITH_TAG_FILTER_PAGINATED)
-        .bind(search_params.tags)
-        .bind(page_size as i32)
-        .bind(offset as i32)
-        .bind(search_params.match_all)
-        .fetch_all(&db)
-        .await
-    {
-        Ok(res) => res.into_iter().map(|item| item.id).collect::<Vec<_>>(),
-        Err(e) => return err_resp_log!(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
-    };
-
-    let posts = match query_as::<_, PostBriefModel>(GET_POST_WITH_BRIEF_MODEL)
-        .bind(&ids)
-        .fetch_all(&db)
-        .await
-    {
-        Ok(posts) => posts,
-        Err(e) => return err_resp_log!(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
-    };
-
-    let resp = Response { posts, pagination };
-    succ_resp(StatusCode::OK, serde_json::to_value(resp).unwrap())
-}

backend/server/src/modules/blog/api/posts/get_identifier.rs

@@ -1,132 +0,0 @@
-use crate::{err_resp_log, utils::axum_response::succ_resp};
-
-use axum::{
-    extract::{Path, State},
-    http::StatusCode,
-    response::IntoResponse,
-};
-use chrono::NaiveDate;
-use futures::future::OptionFuture;
-use serde_json::Value;
-use sqlx::{FromRow, PgPool, query_as};
-use uuid::Uuid;
-
-const SELECT_POST_BY_UUID: &str = include_str!("get_post_by_uuid.sql");
-const SELECT_POST_BY_STR_ID: &str = include_str!("get_post_by_str_id.sql");
-const SELECT_POST_ADJACENT_IDS: &str = include_str!("get_post_adjacent_ids.sql");
-const SELECT_POST_WITH_ADJACENT_MODEL: &str = include_str!("get_post_with_adjacent_model.sql");
-
-#[derive(serde::Serialize, FromRow)]
-struct SelectedPost {
-    id: Uuid,
-    identifier: String,
-    title: String,
-    subtitle: String,
-    status: String,
-    date_created: NaiveDate,
-    date_updated: Option<NaiveDate>,
-    category: String,
-    tags: Vec<String>,
-    content: String,
-    metadata: Option<Value>,
-}
-
-#[derive(serde::Serialize, FromRow)]
-struct AdjacentPost {
-    id: Uuid,
-    identifier: String,
-    title: String,
-    subtitle: String,
-    date_created: NaiveDate,
-    category: String,
-    tags: Vec<String>,
-    header_img: Option<String>,
-}
-
-#[derive(FromRow, Debug)]
-struct AdjacentIds {
-    prev: Option<Uuid>,
-    next: Option<Uuid>,
-}
-
-#[derive(serde::Serialize, Default)]
-struct AdjacentPosts {
-    prev: Option<AdjacentPost>,
-    next: Option<AdjacentPost>,
-}
-
-#[derive(serde::Serialize)]
-struct ResponseModel {
-    post: SelectedPost,
-    adjacent: AdjacentPosts,
-}
-
-pub async fn handler(
-    State(db_connection): State<PgPool>,
-    Path(identifier): Path<String>,
-) -> impl IntoResponse {
-    let post = match if let Ok(id) = identifier.parse::<Uuid>() {
-        select_post_by_uuid(&db_connection, id).await
-    } else {
-        select_post_by_str_id(&db_connection, &identifier).await
-    } {
-        Ok(post) => post,
-        Err(e) => {
-            return match e {
-                sqlx::Error::RowNotFound => {
-                    err_resp_log!(StatusCode::NOT_FOUND, "no matching post")
-                }
-                _ => err_resp_log!(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
-            };
-        }
-    };
-
-    let adj_ids = query_as::<_, AdjacentIds>(SELECT_POST_ADJACENT_IDS)
-        .bind(post.id)
-        .fetch_one(&db_connection)
-        .await
-        .unwrap();
-    let adjacent_prev = OptionFuture::from(
-        adj_ids
-            .prev
-            .map(|id| select_post_with_adjacent_model(&db_connection, id)),
-    )
-    .await
-    .flatten();
-    let adjacent_next = OptionFuture::from(
-        adj_ids
-            .next
-            .map(|id| select_post_with_adjacent_model(&db_connection, id)),
-    )
-    .await
-    .flatten();
-    let adjacent = AdjacentPosts {
-        prev: adjacent_prev,
-        next: adjacent_next,
-    };
-
-    let response = ResponseModel { post, adjacent };
-    succ_resp(StatusCode::OK, serde_json::to_value(response).unwrap())
-}
-
-async fn select_post_by_uuid(db: &PgPool, id: Uuid) -> Result<SelectedPost, sqlx::Error> {
-    query_as::<_, SelectedPost>(SELECT_POST_BY_UUID)
-        .bind(id)
-        .fetch_one(db)
-        .await
-}
-
-async fn select_post_by_str_id(db: &PgPool, id: &str) -> Result<SelectedPost, sqlx::Error> {
-    query_as::<_, SelectedPost>(SELECT_POST_BY_STR_ID)
-        .bind(id)
-        .fetch_one(db)
-        .await
-}
-
-async fn select_post_with_adjacent_model(db: &PgPool, id: Uuid) -> Option<AdjacentPost> {
-    query_as(SELECT_POST_WITH_ADJACENT_MODEL)
-        .bind(id)
-        .fetch_optional(db)
-        .await
-        .unwrap()
-}

backend/server/src/modules/blog/api/posts/get_post_adjacent_ids.sql

@@ -1,13 +0,0 @@
-WITH target_create_date AS (SELECT p.date_created AS date FROM posts p WHERE p.id = $1)
-SELECT (SELECT p.id
-        FROM posts p
-        WHERE p.date_created < t.date
-        ORDER BY p.date_created DESC
-        LIMIT 1) AS prev,
-       (SELECT p.id
-        FROM posts p
-        WHERE p.date_created > t.date
-        ORDER BY p.date_created
-        LIMIT 1) AS next
-FROM target_create_date t
-

backend/server/src/modules/blog/api/posts/get_post_by_str_id.sql

@@ -1,19 +0,0 @@
-SELECT p.id,
-       p.identifier,
-       p.title,
-       p.subtitle,
-       p.status,
-       p.date_created,
-       p.date_updated,
-       c.name                 AS category,
-       (SELECT array_agg(t.name)
-        FROM tags t
-                 JOIN post_tag pt ON pt.tag = t.id
-        WHERE pt.post = p.id) AS tags,
-       p.content,
-       (SELECT json_object_agg(m.meta_key, m.meta_value)
-        FROM metadata m
-        WHERE m.pid = p.id)   AS metadata
-FROM posts p
-         JOIN categories c ON c.id = p.category
-WHERE p.identifier = $1;

backend/server/src/modules/blog/api/posts/get_post_by_uuid.sql

@@ -1,19 +0,0 @@
-SELECT p.id,
-       p.identifier,
-       p.title,
-       p.subtitle,
-       p.status,
-       p.date_created,
-       p.date_updated,
-       c.name                 AS category,
-       (SELECT array_agg(t.name)
-        FROM tags t
-                 JOIN post_tag pt ON pt.tag = t.id
-        WHERE pt.post = p.id) AS tags,
-       p.content,
-       (SELECT json_object_agg(m.meta_key, m.meta_value)
-        FROM metadata m
-        WHERE m.pid = p.id)   AS metadata
-FROM posts p
-         JOIN categories c ON c.id = p.category
-WHERE p.id = $1;

backend/server/src/modules/blog/api/posts/get_post_with_adjacent_model.sql

@@ -1,17 +0,0 @@
-SELECT p.id,
-       identifier,
-       title,
-       subtitle,
-       date_created,
-       c.name                            AS category,
-       (SELECT array_agg(t.name)
-        FROM tags t
-                 JOIN post_tag pt ON pt.tag = t.id
-        WHERE pt.post = p.id)            AS tags,
-       (SELECT m.meta_value
-        FROM metadata m
-        WHERE m.pid = p.id
-          AND m.meta_key = 'header_img') AS header_img
-FROM posts p
-         JOIN public.categories c on c.id = p.category
-WHERE p.id = $1

backend/server/src/modules/blog/api/posts/get_post_with_brief_model.sql

@@ -1,19 +0,0 @@
-SELECT p.id,
-       identifier,
-       title,
-       subtitle,
-       date_created,
-       date_updated,
-       c.name                            AS category,
-       (SELECT array_agg(t.name)
-        FROM tags t
-                 JOIN post_tag pt ON pt.tag = t.id
-        WHERE pt.post = p.id)            AS tags,
-       (SELECT m.meta_value
-        FROM metadata m
-        WHERE m.pid = p.id
-          AND m.meta_key = 'header_img') AS header_img
-FROM posts p
-         JOIN public.categories c on c.id = p.category
-WHERE p.id = ANY ($1)
-ORDER BY p.date_created DESC;

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

@@ -1,3 +0,0 @@
-pub mod get;
-pub mod get_identifier;
-pub mod pagination;

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

@@ -1,52 +0,0 @@
-use crate::{constants::blog::PAGE_SIZE, err_resp_log, utils::axum_response::succ_resp};
-
-use axum::{extract::State, http::StatusCode, response::Response};
-use serde_json::{Value, json};
-use sqlx::{FromRow, PgPool, query_as};
-
-#[derive(FromRow)]
-struct DBPaginationRow {
-    page_count: i32,
-    post_count: i64,
-}
-
-struct PaginationResponse {
-    page_count: i32,
-    post_count: i64,
-}
-
-impl From<DBPaginationRow> for PaginationResponse {
-    fn from(value: DBPaginationRow) -> Self {
-        Self {
-            page_count: value.page_count,
-            post_count: value.post_count,
-        }
-    }
-}
-
-impl From<PaginationResponse> for Value {
-    fn from(value: PaginationResponse) -> Self {
-        json!({
-            "page_count": value.page_count,
-            "post_count": value.post_count
-        })
-    }
-}
-
-pub async fn handler(State(db_connection): State<PgPool>) -> Response<String> {
-    match query_as::<_, DBPaginationRow>(
-        r#"
-        SELECT
-            cast(ceil(count(*) / cast($1 AS FLOAT)) AS INTEGER) AS page_count,
-            count(*) AS post_count
-        FROM posts;
-    "#,
-    )
-    .bind(PAGE_SIZE as i64)
-    .fetch_one(&db_connection)
-    .await
-    {
-        Ok(res) => succ_resp(StatusCode::OK, PaginationResponse::from(res).into()),
-        Err(e) => err_resp_log!(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
-    }
-}

backend/server/src/modules/blog/api/posts/select_post_with_tag_filter_paginated.sql

@@ -1,22 +0,0 @@
-WITH filtered_posts AS
-         (SELECT p.id, p.date_created
-          FROM posts p
-          WHERE $1::text[] IS NULL
-             OR (
-              CASE
-                  WHEN $4 THEN (SELECT COUNT(DISTINCT t.name)
-                                FROM post_tag pt
-                                         JOIN tags t ON pt.tag = t.id
-                                WHERE pt.post = p.id
-                                  AND t.name = ANY ($1::text[])) = cardinality($1)
-                  ELSE EXISTS (SELECT 1
-                               FROM post_tag pt
-                                        JOIN tags t ON pt.tag = t.id
-                               WHERE pt.post = p.id
-                                 AND t.name = ANY ($1::text[]))
-                  END
-              ))
-SELECT id
-FROM filtered_posts
-ORDER BY date_created DESC
-LIMIT $2 OFFSET $3;

backend/server/src/modules/blog/components/check_update/apply.rs

@@ -1,245 +0,0 @@
-use crate::modules::blog::components::check_update::{
-    changes::{Change, Create, Delete, Move, Update},
-    error::Error,
-    utils::{parse_naive_date_str, parse_post_identifier},
-};
-
-use futures::{
-    FutureExt,
-    future::{BoxFuture, join_all},
-};
-use sqlx::{PgPool, Postgres, Row, Transaction, query};
-use tracing::error;
-
-const DELETE_POST_BY_ID: &str = include_str!("sql/delete_post_by_id.sql");
-const GET_TAG_ID: &str = include_str!("sql/get_tag_id.sql");
-const GET_CATEGORY_ID: &str = include_str!("sql/get_category_id.sql");
-const CREATE_RETURN_TAG_ID: &str = include_str!("sql/create_return_tag_id.sql");
-const CREATE_RETURN_CATEGORY_ID: &str = include_str!("sql/create_return_category_id.sql");
-const CREATE_POST_GENERAL: &str = include_str!("sql/create_post_general.sql");
-const CREATE_POST_TAGS: &str = include_str!("sql/create_post_tags.sql");
-const CREATE_POST_META: &str = include_str!("sql/create_post_meta.sql");
-
-pub async fn apply_deltas(db_conn: &PgPool, changes: Vec<Change>) {
-    let handlers = changes
-        .into_iter()
-        .map(|change| match change {
-            Change::Delete(del) => handle_delete(db_conn, del).boxed(),
-            Change::Move(mv) => handle_move(db_conn, mv).boxed(),
-            Change::Update(update) => handle_update(db_conn, update).boxed(),
-            Change::Create(create) => handle_create(db_conn, create).boxed(),
-        })
-        .collect::<Vec<BoxFuture<'_, ()>>>();
-
-    join_all(handlers).await;
-}
-
-async fn handle_delete(db: &PgPool, del: Delete) {
-    if let Err(e) = query(DELETE_POST_BY_ID).bind(del.uuid).execute(db).await {
-        error!(
-            "failed to delete post: {}, {}",
-            del.uuid.to_string(),
-            e.to_string()
-        )
-    }
-}
-
-async fn handle_move(db: &PgPool, mv: Move) {
-    handle_delete(
-        db,
-        Delete {
-            uuid: mv.uuid,
-            path: Some(mv.from),
-        },
-    )
-    .await;
-    handle_create(
-        db,
-        Create {
-            uuid: mv.uuid,
-            path: mv.to,
-            payload: mv.payload,
-        },
-    )
-    .await;
-}
-
-async fn handle_update(db: &PgPool, update: Update) {
-    handle_delete(
-        db,
-        Delete {
-            uuid: update.uuid,
-            path: Some(update.path.clone()),
-        },
-    )
-    .await;
-    handle_create(
-        db,
-        Create {
-            uuid: update.uuid,
-            path: update.path,
-            payload: update.payload,
-        },
-    )
-    .await;
-}
-
-async fn handle_create(db: &PgPool, create: Create) {
-    let mut tx = db.begin().await.unwrap();
-
-    let identifier = parse_post_identifier(&create.path).unwrap();
-
-    let tags_json = create.payload.meta["tags"].clone();
-    let tags: Vec<_> = if let Some(tags) = tags_json.as_array() {
-        tags.iter().filter_map(|tag| tag.as_str()).collect()
-    } else {
-        vec![]
-    };
-    let mut tag_ids = vec![];
-    for tag in tags {
-        match get_or_create_tag_id(&mut tx, tag).await {
-            Ok(tid) => tag_ids.push(tid),
-            Err(e) => {
-                error!("failed to fetch or create tag ({}): {}", tag, e);
-                return;
-            }
-        }
-    }
-
-    let category_json = create.payload.meta["category"].clone();
-    let category = category_json.as_str().unwrap_or("Uncategorized");
-    let category_id = match get_or_create_category_id(&mut tx, category).await {
-        Ok(id) => id,
-        Err(e) => {
-            error!(
-                "failed to fetch category id for post {}: {}",
-                &identifier, e
-            );
-            return;
-        }
-    };
-
-    const KEY_TO_SKIP: &[&str] = &[
-        "category", "status", "id", "date", "update", "tags", "title", "subtitle",
-    ];
-    let (post_meta_key, post_meta_value): (Vec<String>, Vec<String>) =
-        if let Some(kv) = create.payload.meta.as_object() {
-            kv.iter()
-                .filter(|(k, _)| !KEY_TO_SKIP.contains(&&***k))
-                .map(|(k, v)| (k.clone(), v.as_str().unwrap().to_string()))
-                .collect()
-        } else {
-            (vec![], vec![])
-        };
-
-    let meta = create.payload.meta;
-    let post_id = create.uuid;
-    let post_identifier = &identifier;
-    let post_title = meta
-        .get("title")
-        .map(|t| t.as_str().unwrap())
-        .unwrap_or("Untitled");
-    let post_subtitle = meta
-        .get("subtitle")
-        .map(|t| t.as_str().unwrap())
-        .unwrap_or("");
-    let post_date_created = if let Some(Some(date)) = meta
-        .get("date")
-        .map(|d| parse_naive_date_str(d.as_str().unwrap_or("")))
-    {
-        date
-    } else {
-        error!("failed to parse `date` for post: {}", post_identifier);
-        return;
-    };
-    let post_date_updated = meta
-        .get("update")
-        .map(|d| parse_naive_date_str(d.as_str().unwrap_or("")))
-        .unwrap_or(None);
-    let post_status = meta.get("status").map(|v| v.as_str()).unwrap_or(None);
-    let post_content = create.payload.content;
-    let post_hash = create.payload.hash;
-
-    if let Err(e) = query(CREATE_POST_GENERAL)
-        .bind(post_id)
-        .bind(post_identifier)
-        .bind(post_title)
-        .bind(post_subtitle)
-        .bind(post_date_created)
-        .bind(post_date_updated)
-        .bind(post_status)
-        .bind(post_content)
-        .bind(post_hash)
-        .bind(category_id)
-        .execute(&mut *tx)
-        .await
-    {
-        error!("failed to insert post {}: {}", &identifier, e);
-        return;
-    }
-
-    if let Err(e) = query(CREATE_POST_TAGS)
-        .bind(post_id)
-        .bind(tag_ids)
-        .execute(&mut *tx)
-        .await
-    {
-        error!("failed to insert post {}: {}", &identifier, e);
-        return;
-    }
-
-    if let Err(e) = query(CREATE_POST_META)
-        .bind(post_id)
-        .bind(post_meta_key)
-        .bind(post_meta_value)
-        .execute(&mut *tx)
-        .await
-    {
-        error!("failed to insert post {}: {}", &identifier, e);
-        return;
-    }
-
-    tx.commit().await.unwrap();
-}
-
-async fn get_or_create_tag_id(
-    db: &mut Transaction<'_, Postgres>,
-    tag_name: &str,
-) -> Result<i32, Error> {
-    get_create_id(db, tag_name, GET_TAG_ID, CREATE_RETURN_TAG_ID).await
-}
-
-async fn get_or_create_category_id(
-    db: &mut Transaction<'_, Postgres>,
-    category_name: &str,
-) -> Result<i32, Error> {
-    get_create_id(
-        db,
-        category_name,
-        GET_CATEGORY_ID,
-        CREATE_RETURN_CATEGORY_ID,
-    )
-    .await
-}
-
-async fn get_create_id(
-    db: &mut Transaction<'_, Postgres>,
-    field_name: &str,
-    fetch_query: &str,
-    create_fetch_query: &str,
-) -> Result<i32, Error> {
-    if let Some(id) = query(fetch_query)
-        .bind(field_name)
-        .fetch_optional(&mut **db)
-        .await?
-    {
-        Ok(id.get("id"))
-    } else {
-        let id = query(create_fetch_query)
-            .bind(field_name)
-            .fetch_one(&mut **db)
-            .await?
-            .get("id");
-        Ok(id)
-    }
-}

backend/server/src/modules/blog/components/check_update/changes.rs

@@ -1,68 +0,0 @@
-use std::path::PathBuf;
-
-use markdown::MdFile;
-
-use uuid::Uuid;
-
-#[allow(dead_code)]
-#[derive(Debug)]
-pub enum Change {
-    Delete(Delete),
-    Move(Move),
-    Update(Update),
-    Create(Create),
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Clone)]
-pub struct Delete {
-    pub uuid: Uuid,
-    pub path: Option<PathBuf>,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Clone)]
-pub struct Move {
-    pub uuid: Uuid,
-    pub from: PathBuf,
-    pub to: PathBuf,
-    pub payload: MdFile,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Clone)]
-pub struct Update {
-    pub uuid: Uuid,
-    pub path: PathBuf,
-    pub payload: MdFile,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Clone)]
-pub struct Create {
-    pub uuid: Uuid,
-    pub path: PathBuf,
-    pub payload: MdFile,
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct CreateDelete2UpdateSlot {
-    pub create: Option<Create>,
-    pub delete: Option<Delete>,
-}
-
-impl CreateDelete2UpdateSlot {
-    pub fn to_change(&self) -> Option<Change> {
-        match (&self.create, &self.delete) {
-            (Some(create), Some(delete)) => Some(Change::Move(Move {
-                uuid: create.uuid,
-                from: delete.path.clone()?,
-                to: create.path.clone(),
-                payload: create.payload.clone(),
-            })),
-            (Some(create), None) => Some(Change::Create(create.clone())),
-            (None, Some(delete)) => Some(Change::Delete(delete.clone())),
-            (None, None) => None,
-        }
-    }
-}

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

@@ -1,18 +0,0 @@
-use markdown::error::Error as MarkdownError;
-
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum Error {
-    #[error("markdown file error")]
-    MdFile(#[from] MarkdownError),
-
-    #[error("db error")]
-    Db(#[from] sqlx::Error),
-
-    #[error("git error")]
-    Git2(#[from] git2::Error),
-
-    #[error("git remote url mismatch")]
-    GitUrlMismatch,
-}

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

@@ -1,82 +0,0 @@
-pub mod apply;
-pub mod changes;
-mod error;
-mod pull;
-pub mod utils;
-
-use std::{env, path::PathBuf, sync::Arc};
-
-use crate::{
-    constants::config::general::{default_value, var_name},
-    modules::blog::components::{
-        check_update::{apply::apply_deltas, pull::fetch_deltas},
-        static_rsc::GIT_WORK_DIR,
-    },
-    scheduler::task_func::AsyncTaskFunc,
-};
-use macros::panic_with_log;
-
-use sqlx::PgPool;
-use tracing::{Level, log::error, trace};
-
-#[derive(Debug)]
-struct Args {
-    db_connection: PgPool,
-    git_work_dir: PathBuf,
-    git_url: String,
-    git_remote_name: String,
-    git_remote_branch: String,
-}
-
-pub fn task(db_connection: PgPool) -> impl AsyncTaskFunc {
-    // 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());
-
-    let arc_args = Arc::new(Args {
-        db_connection,
-        git_work_dir: GIT_WORK_DIR.clone(),
-        git_url,
-        git_remote_name,
-        git_remote_branch,
-    });
-
-    move || Box::pin(workflow(arc_args.clone()))
-}
-
-async fn workflow(args: Arc<Args>) {
-    let deltas = match fetch_deltas(
-        &args.git_url,
-        &args.git_remote_name,
-        &args.git_remote_branch,
-        &args.git_work_dir,
-    )
-    .await
-    {
-        Ok(updates) => updates,
-        Err(e) => {
-            error!("delta parsing error: {}", e);
-            return;
-        }
-    };
-
-    if deltas.is_empty() {
-        trace!("blog git already up-to-date");
-        return;
-    }
-
-    apply_deltas(&args.db_connection, deltas).await;
-}

backend/server/src/modules/blog/components/check_update/pull.rs

@@ -1,175 +0,0 @@
-use std::{collections::HashMap, fs::remove_dir_all, path::Path, path::PathBuf};
-
-use crate::{
-    modules::blog::components::{
-        check_update::{
-            changes::{Change, Create, CreateDelete2UpdateSlot, Delete, Update},
-            error::Error,
-            utils::extract_post_id,
-        },
-        static_rsc::BLOG_POST_PATH_PATTERN,
-    },
-    utils::{git, git::FileDelta},
-};
-use markdown::MdFile;
-
-use git2::{Delta, Repository};
-use tracing::{error, warn};
-use uuid::Uuid;
-
-pub async fn fetch_deltas(
-    git_url: &str,
-    git_remote_name: &str,
-    git_remote_branch: &str,
-    git_work_dir: &PathBuf,
-) -> Result<Vec<Change>, Error> {
-    let repo = match Repository::open(git_work_dir) {
-        Ok(repo) => repo,
-        Err(_) => match Repository::clone(git_url, git_work_dir) {
-            Ok(repo) => repo,
-            Err(e) => {
-                error!("failed to clone blog content git({}): {}", &git_url, e);
-                return Err(e.into());
-            }
-        },
-    };
-
-    let mut remote = match repo.find_remote(git_remote_name) {
-        Ok(remote) => remote,
-        Err(e) => {
-            remove_dir_all(git_work_dir).unwrap();
-            warn!(
-                "cannot find git remote ({}), reinitializing: {}",
-                git_remote_name, e
-            );
-            return Err(e.into());
-        }
-    };
-    if remote.url().is_some_and(|url| url != git_url) {
-        remove_dir_all(git_work_dir).unwrap();
-        warn!(
-            "git remote url mismatch (expected: {}, actual: {}), reinitializing",
-            git_url,
-            remote.url().unwrap()
-        );
-        return Err(Error::GitUrlMismatch);
-    }
-
-    let fetched_commit = git::do_fetch(&repo, &[git_remote_branch], &mut remote)?;
-    let commit_deltas = git::calculate_diff(
-        &repo,
-        &repo.reference_to_annotated_commit(&repo.head()?)?,
-        &fetched_commit,
-    )?;
-
-    // dbg!(&commit_deltas);
-    let mut changes: Vec<Change> = vec![];
-    let mut non_delete_deltas: Vec<FileDelta> = vec![];
-
-    // process deleted deltas before merging commit to prevent "file not found" os error
-    for delta in commit_deltas.into_iter() {
-        let relative_file_path = delta
-            .new_path
-            .clone()
-            .expect("cannot parse modified post `new_path`");
-
-        if !should_delta_tracked(&relative_file_path) {
-            continue;
-        }
-
-        if delta.status == Delta::Deleted {
-            let file_path = &git_work_dir.join(relative_file_path);
-            if let Some(id) = extract_post_id(&MdFile::from_file(file_path)?) {
-                changes.push(Change::Delete(Delete {
-                    uuid: id,
-                    path: Some(file_path.clone()),
-                }))
-            } else {
-                error!("failed to parse uuid for file {}", file_path.display());
-                // todo: add to unresolved error list
-            }
-        } else {
-            non_delete_deltas.push(delta);
-        }
-    }
-
-    git::do_merge(&repo, git_remote_branch, fetched_commit)?;
-
-    // process adds and modifies deltas
-    for delta in non_delete_deltas.into_iter() {
-        let file_path = &git_work_dir.join(
-            delta
-                .new_path
-                .expect("cannot parse modified post `new_path`"),
-        );
-        match delta.status {
-            Delta::Added => {
-                let md_file = MdFile::from_file(file_path)?;
-                if let Some(id) = extract_post_id(&md_file) {
-                    changes.push(Change::Create(Create {
-                        uuid: id,
-                        path: file_path.clone(),
-                        payload: md_file,
-                    }))
-                } else {
-                    error!("failed to parse uuid for file {}", file_path.display());
-                    // todo: add to unresolved error list
-                }
-            }
-            Delta::Modified => {
-                let md_file = MdFile::from_file(file_path)?;
-                if let Some(id) = extract_post_id(&md_file) {
-                    changes.push(Change::Update(Update {
-                        uuid: id,
-                        path: file_path.clone(),
-                        payload: md_file,
-                    }))
-                } else {
-                    error!("failed to parse uuid for file {}", file_path.display());
-                    // todo: add to unresolved error list
-                }
-            }
-            Delta::Deleted => continue,
-            _ => {
-                error!("unsupported delta type on file {}", file_path.display());
-                continue;
-            }
-        }
-    }
-
-    // merge adds and deletes deltas to moves
-    let changes = merge_changes(changes);
-
-    Ok(changes)
-}
-
-fn merge_changes(changes: Vec<Change>) -> Vec<Change> {
-    let mut slots: HashMap<Uuid, CreateDelete2UpdateSlot> = HashMap::new();
-    let mut merged: Vec<Change> = Vec::new();
-
-    for change in changes {
-        match change {
-            Change::Create(create) => {
-                let id = create.uuid;
-                slots.entry(id).or_default().create = Some(create);
-            }
-            Change::Delete(delete) => {
-                let id = delete.uuid;
-                slots.entry(id).or_default().delete = Some(delete);
-            }
-            _ => merged.push(change),
-        }
-    }
-
-    for slot in slots.values() {
-        if let Some(change) = slot.to_change() {
-            merged.push(change);
-        }
-    }
-
-    merged
-}
-
-fn should_delta_tracked(path: &Path) -> bool {
-    BLOG_POST_PATH_PATTERN.is_match(path.to_str().unwrap())
-}

backend/server/src/modules/blog/components/check_update/sql/create_post_general.sql

@@ -1,3 +0,0 @@
-INSERT INTO posts
-(id, identifier, title, subtitle, date_created, date_updated, status, content, hash, category)
-VALUES ($1, $2, $3, $4, $5, $6, COALESCE($7, 'draft'), $8, $9, $10);

backend/server/src/modules/blog/components/check_update/sql/create_post_meta.sql

@@ -1,3 +0,0 @@
-INSERT INTO metadata (pid, meta_key, meta_value)
-SELECT $1, key, value
-FROM UNNEST($2, $3) AS k(key, value);

backend/server/src/modules/blog/components/check_update/sql/create_post_tags.sql

@@ -1,3 +0,0 @@
-INSERT INTO post_tag (post, tag)
-SELECT $1, tag
-FROM UNNEST($2) AS t(tag);

backend/server/src/modules/blog/components/check_update/sql/create_return_category_id.sql

@@ -1,3 +0,0 @@
-INSERT INTO categories(name)
-VALUES ($1)
-RETURNING id;

backend/server/src/modules/blog/components/check_update/sql/create_return_tag_id.sql

@@ -1,3 +0,0 @@
-INSERT INTO tags(name)
-VALUES ($1)
-RETURNING id;

backend/server/src/modules/blog/components/check_update/sql/delete_post_by_id.sql

@@ -1,3 +0,0 @@
-DELETE
-FROM posts
-WHERE id = $1;

backend/server/src/modules/blog/components/check_update/sql/get_category_id.sql

@@ -1,3 +0,0 @@
-SELECT id
-FROM categories
-WHERE name = $1;

backend/server/src/modules/blog/components/check_update/sql/get_tag_id.sql

@@ -1,3 +0,0 @@
-SELECT id
-FROM tags
-WHERE name = $1;

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

@@ -1,67 +0,0 @@
-use std::path::Path;
-
-use crate::constants::{
-    config::general::{default_value, var_name},
-    time::DEFAULT_NAIVE_DATE_FORMAT,
-};
-
-use chrono::NaiveDate;
-use dirs::home_dir;
-use markdown::MdFile;
-use tracing::warn;
-use uuid::Uuid;
-
-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 extract_post_id(post: &MdFile) -> Option<Uuid> {
-    match post.meta["id"].as_str() {
-        Some(id) => Uuid::parse_str(id).ok(),
-        None => None,
-    }
-}
-
-pub fn parse_post_identifier(path: &Path) -> Option<String> {
-    if let Some(comp) = path.components().nth_back(1) {
-        comp.as_os_str().to_str().map(|s| s.to_string())
-    } else {
-        None
-    }
-}
-
-pub fn parse_naive_date_str(date_str: &str) -> Option<NaiveDate> {
-    NaiveDate::parse_from_str(date_str, DEFAULT_NAIVE_DATE_FORMAT).ok()
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::modules::blog::components::check_update::utils::parse_naive_date_str;
-    use chrono::NaiveDate;
-
-    #[test]
-    fn test_parse_naive_date() {
-        assert_eq!(
-            NaiveDate::from_ymd_opt(2015, 1, 1),
-            parse_naive_date_str("2015-1-01")
-        );
-    }
-}

backend/server/src/modules/blog/components/consistency_guard/checker.rs

@@ -1,130 +0,0 @@
-use std::{
-    collections::HashMap,
-    fs,
-    path::{Path, PathBuf},
-    str::FromStr,
-};
-
-use crate::modules::blog::components::{
-    check_update::{
-        changes::{Change, Create, Delete, Update},
-        utils::extract_post_id,
-    },
-    consistency_guard::{error::Error, utils::rec_find_dir_entries},
-    static_rsc::BLOG_POST_PATH_PATTERN,
-};
-use markdown::MdFile;
-
-use sqlx::{FromRow, PgPool, query_as};
-use tracing::error;
-use uuid::Uuid;
-
-const FETCH_POST_HASH: &str = include_str!("sql/fetch_post_hash.sql");
-
-#[derive(Debug, FromRow)]
-struct PostIdHash {
-    id: Uuid,
-    hash: String,
-}
-
-struct PostPath {
-    id: Uuid,
-    path: PathBuf,
-    payload: MdFile,
-}
-
-#[derive(Default)]
-struct DeltaSlot {
-    local: Option<PostPath>,
-    db: Option<PostIdHash>,
-}
-
-impl DeltaSlot {
-    pub fn to_change(&self) -> Option<Change> {
-        match (&self.local, &self.db) {
-            (Some(local), Some(db)) => {
-                if local.payload.hash == db.hash {
-                    None
-                } else {
-                    Some(Change::Update(Update {
-                        uuid: local.id,
-                        path: local.path.clone(),
-                        payload: local.payload.clone(),
-                    }))
-                }
-            }
-            (Some(local), None) => Some(Change::Create(Create {
-                uuid: local.id,
-                path: local.path.clone(),
-                payload: local.payload.clone(),
-            })),
-            (None, Some(db)) => Some(Change::Delete(Delete {
-                uuid: db.id,
-                path: None,
-            })),
-            (None, None) => None,
-        }
-    }
-}
-
-pub async fn compare_db_local_post_hash(
-    db: &PgPool,
-    git_work_dir: &Path,
-) -> Result<Vec<Change>, Error> {
-    let db_post_hashes = query_as::<_, PostIdHash>(FETCH_POST_HASH)
-        .fetch_all(db)
-        .await?;
-    let local_posts = fetch_local_posts(git_work_dir)?;
-    calculate_post_changes(local_posts, db_post_hashes)
-}
-
-fn fetch_local_posts(git_work_dir: &Path) -> Result<Vec<PostPath>, Error> {
-    let mut post_hashes = vec![];
-    let entries = rec_find_dir_entries(&git_work_dir.join("posts"))?;
-
-    for entry in entries {
-        let relative_pth = entry.strip_prefix(git_work_dir).unwrap();
-        if !BLOG_POST_PATH_PATTERN.is_match(relative_pth.to_str().unwrap()) {
-            continue;
-        }
-        let post_str = fs::read_to_string(&entry)?;
-        let post = MdFile::from_str(&post_str)?;
-        let post_id = match extract_post_id(&post) {
-            None => {
-                error!(
-                    "failed to parse uuid for file {}, skipping",
-                    &entry.display()
-                );
-                continue;
-            }
-            Some(v) => v,
-        };
-        post_hashes.push(PostPath {
-            id: post_id,
-            path: entry,
-            payload: post,
-        });
-    }
-
-    Ok(post_hashes)
-}
-
-fn calculate_post_changes(local: Vec<PostPath>, db: Vec<PostIdHash>) -> Result<Vec<Change>, Error> {
-    let mut slots: HashMap<Uuid, DeltaSlot> = HashMap::new();
-    for local_post in local {
-        let id = local_post.id;
-        slots.entry(id).or_default().local = Some(local_post);
-    }
-    for db_post in db {
-        let id = db_post.id;
-        slots.entry(id).or_default().db = Some(db_post);
-    }
-
-    let mut changes = vec![];
-    for slot in slots.values() {
-        if let Some(change) = slot.to_change() {
-            changes.push(change);
-        }
-    }
-    Ok(changes)
-}

backend/server/src/modules/blog/components/consistency_guard/error.rs

@@ -1,19 +0,0 @@
-use std::io;
-use std::path::PathBuf;
-
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum Error {
-    #[error("db error")]
-    Db(#[from] sqlx::Error),
-
-    #[error("io error")]
-    Io(#[from] io::Error),
-
-    #[error("invalid path: {0}")]
-    InvalidPath(PathBuf),
-
-    #[error("invalid md file")]
-    MdFile(#[from] markdown::error::Error),
-}

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

@@ -1,44 +0,0 @@
-mod checker;
-mod error;
-mod utils;
-
-use std::{path::PathBuf, sync::Arc};
-
-use crate::{
-    modules::blog::components::{
-        check_update::apply::apply_deltas, consistency_guard::checker::compare_db_local_post_hash,
-        static_rsc::GIT_WORK_DIR,
-    },
-    scheduler::task_func::AsyncTaskFunc,
-};
-
-use sqlx::PgPool;
-use tracing::{error, trace};
-
-struct Args {
-    db_connection: PgPool,
-    git_work_dir: PathBuf,
-}
-
-pub fn task(db_connection: PgPool) -> impl AsyncTaskFunc {
-    let args = Arc::new(Args {
-        db_connection,
-        git_work_dir: GIT_WORK_DIR.clone(),
-    });
-    move || Box::pin(workflow(args.clone()))
-}
-
-async fn workflow(args: Arc<Args>) {
-    let db = &args.db_connection;
-    let git_work_dir = &args.git_work_dir;
-
-    let changes = match compare_db_local_post_hash(db, git_work_dir).await {
-        Ok(c) => c,
-        Err(e) => {
-            error!("failed to compare db and local post list: {}", e);
-            return;
-        }
-    };
-    apply_deltas(db, changes).await;
-    trace!("local-database consistency checked");
-}

backend/server/src/modules/blog/components/consistency_guard/sql/fetch_post_hash.sql

@@ -1,2 +0,0 @@
-SELECT id, hash
-FROM posts

backend/server/src/modules/blog/components/consistency_guard/utils.rs

@@ -1,78 +0,0 @@
-use std::{
-    fs,
-    path::{Path, PathBuf},
-};
-
-use crate::modules::blog::components::consistency_guard::error::Error;
-
-pub fn rec_find_dir_entries(entry: &Path) -> Result<Vec<PathBuf>, Error> {
-    if !entry.exists() {
-        return Err(Error::InvalidPath(entry.to_path_buf()));
-    }
-
-    let mut result = vec![];
-
-    if !entry.is_dir() {
-        return Ok(vec![entry.to_path_buf()]);
-    }
-
-    for entry in fs::read_dir(entry)? {
-        let entry = entry?;
-        let path = entry.path();
-
-        if path.is_dir() {
-            result.extend(rec_find_dir_entries(&path)?);
-        } else {
-            result.push(path);
-        }
-    }
-
-    Ok(result)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs::{self, File};
-    use tempfile::TempDir;
-
-    #[test]
-    fn test_valid_directory() {
-        let temp_dir = TempDir::new().unwrap();
-        let dir_path = temp_dir.path();
-
-        fs::create_dir(dir_path.join("subdir")).unwrap();
-        File::create(dir_path.join("file1.txt")).unwrap();
-        File::create(dir_path.join("subdir/file2.txt")).unwrap();
-
-        let entries = rec_find_dir_entries(dir_path).unwrap();
-        assert_eq!(entries.len(), 2);
-    }
-
-    #[test]
-    fn test_non_existent_path() {
-        let non_existent = PathBuf::from("/non/existent/path");
-        assert!(matches!(
-            rec_find_dir_entries(&non_existent),
-            Err(Error::InvalidPath(_))
-        ));
-    }
-
-    #[test]
-    fn test_single_file() {
-        let temp_dir = TempDir::new().unwrap();
-        let file_path = temp_dir.path().join("test.txt");
-        File::create(&file_path).unwrap();
-
-        let entries = rec_find_dir_entries(&file_path).unwrap();
-        assert_eq!(entries.len(), 1);
-        assert_eq!(entries[0], file_path);
-    }
-
-    #[test]
-    fn test_empty_directory() {
-        let temp_dir = TempDir::new().unwrap();
-        let entries = rec_find_dir_entries(temp_dir.path()).unwrap();
-        assert!(entries.is_empty());
-    }
-}

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

@@ -1,4 +0,0 @@
-pub mod check_update;
-pub mod consistency_guard;
-pub mod rag;
-mod static_rsc;

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

@@ -1 +0,0 @@
-

backend/server/src/modules/blog/components/static_rsc.rs

@@ -1,31 +0,0 @@
-use std::{
-    env,
-    path::{Path, PathBuf},
-    sync::LazyLock,
-};
-
-use crate::{
-    constants::config::general::{default_value, var_name},
-    modules::blog::components::check_update::utils::expand_path,
-};
-
-use regex::Regex;
-use tracing::warn;
-
-pub static BLOG_POST_PATH_PATTERN: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"^posts/\d{4}/[a-zA-Z0-9-]+/index\.md$").unwrap());
-
-pub static GIT_WORK_DIR: LazyLock<PathBuf> = LazyLock::new(|| {
-    let path = if let Ok(default_work_path) = env::var(var_name::WORK_DIR) {
-        expand_path(default_work_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")
-});

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

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

backend/server/src/modules/mod.rs

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

backend/server/src/scheduler/error.rs

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

backend/server/src/scheduler/mod.rs

@@ -1,54 +0,0 @@
-use std::{collections::HashMap, sync::Arc};
-
-use crate::scheduler::{error::SchedulerError, tasks::CronTask, utils::execute};
-
-use futures::future::join_all;
-use tracing::warn;
-
-pub mod error;
-pub mod task_func;
-pub mod tasks;
-mod utils;
-
-pub type TaskPool = HashMap<String, Arc<Box<dyn CronTask>>>;
-
-#[derive(Default)]
-pub struct Scheduler {
-    task_pool: TaskPool,
-}
-
-impl Scheduler {
-    /// Start all tasks in the scheduler
-    pub async fn start(&self) {
-        let fut = self
-            .task_pool
-            .clone()
-            .into_iter()
-            .map(|(name, task)| execute(name, task))
-            .collect::<Vec<_>>();
-        // self.runner.run_all().await
-        join_all(fut).await;
-    }
-
-    pub fn insert(&mut self, task: (&str, Box<dyn CronTask>)) -> Result<&Self, SchedulerError> {
-        let (k, v) = task;
-        if self.task_pool.insert(k.into(), v.into()).is_some() {
-            warn!("task list duplicated key detected: {}", k);
-        }
-        Ok(self)
-    }
-
-    pub fn insert_list(
-        &mut self,
-        tasks: Vec<(&str, Box<dyn CronTask>)>,
-    ) -> Result<&Self, SchedulerError> {
-        for task in tasks {
-            self.insert(task)?;
-        }
-        Ok(self)
-    }
-
-    pub fn new() -> Self {
-        Self::default()
-    }
-}

backend/server/src/scheduler/task_func.rs

@@ -1,15 +0,0 @@
-use std::pin::Pin;
-
-pub trait TaskFunc: Fn() + Send + Sync + 'static {}
-
-impl<T> TaskFunc for T where T: Fn() + Send + Sync + Clone + 'static {}
-
-pub trait AsyncTaskFunc:
-    Fn() -> Pin<Box<dyn Future<Output = ()> + Send>> + Send + Sync + 'static
-{
-}
-
-impl<T> AsyncTaskFunc for T where
-    T: Fn() -> Pin<Box<dyn Future<Output = ()> + Send>> + Send + Sync + Clone + 'static
-{
-}

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

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

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

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

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

@@ -1,14 +0,0 @@
-use std::pin::Pin;
-
-use chrono::{DateTime, Utc};
-
-#[allow(dead_code)]
-pub mod async_basic;
-
-#[allow(dead_code)]
-pub mod basic;
-
-pub trait CronTask: Send + Sync {
-    fn get_next_execution(&self) -> Option<DateTime<Utc>>;
-    fn call(&self) -> Pin<Box<dyn Future<Output = ()> + Send + '_>>;
-}

backend/server/src/scheduler/utils.rs

@@ -1,32 +0,0 @@
-use std::{sync::Arc, time::Duration};
-
-use crate::scheduler::{error::SchedulerError, tasks::CronTask};
-
-use chrono::{DateTime, Utc};
-use tokio::time::{Sleep, sleep};
-
-pub fn duration_from_now(future: DateTime<Utc>) -> Duration {
-    future
-        .signed_duration_since(Utc::now())
-        .to_std()
-        .unwrap_or(Duration::ZERO)
-}
-
-pub fn sleeper_from_now(future: DateTime<Utc>) -> Sleep {
-    sleep(duration_from_now(future))
-}
-
-#[allow(unused_variables)]
-pub async fn execute(name: String, func: Arc<Box<dyn CronTask>>) -> Result<(), SchedulerError> {
-    // todo: stats
-    while let Some(next_execution) = func.get_next_execution() {
-        let sleeper = sleeper_from_now(next_execution);
-        tokio::pin!(sleeper);
-        tokio::select! {
-            _ = sleeper => {
-                func.call().await
-            }
-        }
-    }
-    Ok(())
-}

backend/server/src/utils/axum_response.rs

@@ -1,51 +0,0 @@
-use axum::{
-    http::{StatusCode, header::CONTENT_TYPE},
-    response::Response,
-};
-use serde_json::{Value, json};
-
-#[macro_export]
-macro_rules! err_resp_log {
-    ($code:expr, $msg:expr) => {{
-        use tracing::error;
-        use $crate::utils::axum_response::err_resp;
-
-        error!("{}", $msg);
-        err_resp($code, $msg, None)
-    }};
-    ($code:expr, $msg:expr, $body:expr) => {{
-        use tracing::error;
-        use $crate::utils::axum_response::err_resp;
-
-        error!("{}", $msg);
-        err_resp($code, $msg, Some($body))
-    }};
-}
-
-pub fn err_resp(code: StatusCode, err_msg: &str, body: Option<Value>) -> Response<String> {
-    let mut payload = json!({
-        "status": "error",
-        "msg": err_msg,
-    });
-    if let Some(body) = body {
-        payload["data"] = body;
-    }
-
-    resp_json(code, payload)
-}
-
-pub fn succ_resp(code: StatusCode, payload: Value) -> Response<String> {
-    let payload = json!({
-        "status": "success",
-        "data": payload
-    });
-    resp_json(code, payload)
-}
-
-pub fn resp_json(code: StatusCode, payload: Value) -> Response<String> {
-    Response::builder()
-        .status(code)
-        .header(CONTENT_TYPE, "application/json")
-        .body(payload.to_string())
-        .unwrap()
-}

backend/server/src/utils/git.rs

@@ -1,166 +0,0 @@
-/// git operations
-/// 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::{
-    AnnotatedCommit, AutotagOption, Delta, FetchOptions, Reference, Remote, Repository, build,
-};
-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,
-}
-
-pub fn do_fetch<'a>(
-    repo: &'a Repository,
-    refs: &[&str],
-    remote: &'a mut Remote,
-) -> Result<AnnotatedCommit<'a>, git2::Error> {
-    let mut fetch_option = FetchOptions::new();
-
-    fetch_option.download_tags(AutotagOption::All);
-    remote.fetch(refs, Some(&mut fetch_option), None)?;
-
-    let fetch_head = repo.find_reference("FETCH_HEAD")?;
-    repo.reference_to_annotated_commit(&fetch_head)
-}
-
-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());
-    lb.set_target(rc.id(), &msg)?;
-    repo.set_head(&name)?;
-    repo.checkout_head(Some(build::CheckoutBuilder::default().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)?)?;
-
-    let msg = format!("merge({}) -> {}", remote.id(), local.id());
-    let sig = repo.signature()?;
-    let local_commit = repo.find_commit(local.id())?;
-    let remote_commit = repo.find_commit(remote.id())?;
-
-    let _merge_commit = repo.commit(
-        Some("HEAD"),
-        &sig,
-        &sig,
-        &msg,
-        &result_tree,
-        &[&local_commit, &remote_commit],
-    )?;
-    repo.checkout_head(None)?;
-    Ok(())
-}
-
-pub fn do_merge<'a>(
-    repo: &'a Repository,
-    remote_branch: &str,
-    fetch_commit: AnnotatedCommit<'a>,
-) -> Result<(), git2::Error> {
-    let analysis = repo.merge_analysis(&[&fetch_commit])?;
-    let head_commit = repo.reference_to_annotated_commit(&repo.head()?)?;
-
-    if analysis.0.is_fast_forward() {
-        let ref_name = format!("refs/heads/{}", remote_branch);
-        match repo.find_reference(&ref_name) {
-            Ok(mut r) => {
-                fast_forward(repo, &mut r, &fetch_commit)?;
-            }
-            Err(_) => {
-                repo.reference(
-                    &ref_name,
-                    fetch_commit.id(),
-                    true,
-                    &format!("({}) -> {}", remote_branch, fetch_commit.id()),
-                )?;
-                repo.set_head(&ref_name)?;
-                repo.checkout_head(Some(
-                    build::CheckoutBuilder::default()
-                        .allow_conflicts(true)
-                        .conflict_style_merge(true)
-                        .force(),
-                ))?;
-            }
-        };
-    } else if analysis.0.is_normal() {
-        normal_merge(repo, &head_commit, &fetch_commit)?;
-    }
-
-    Ok(())
-}
-
-pub fn calculate_diff(
-    repo: &Repository,
-    local: &AnnotatedCommit,
-    remote: &AnnotatedCommit,
-) -> Result<Vec<FileDelta>, git2::Error> {
-    let local_tree = repo.find_commit(local.id())?.tree()?;
-    let remote_tree = repo.find_commit(remote.id())?.tree()?;
-    let diff = repo.diff_tree_to_tree(Some(&local_tree), Some(&remote_tree), None)?;
-
-    let mut updated_files: Vec<FileDelta> = Vec::new();
-
-    if let Err(e) = diff.foreach(
-        &mut |d, _| {
-            updated_files.push(FileDelta {
-                old_path: d.old_file().path().map(PathBuf::from),
-                new_path: d.new_file().path().map(PathBuf::from),
-                status: d.status(),
-            });
-            true
-        },
-        None,
-        None,
-        None,
-    ) {
-        error!("error at calculating diff: {:?}", e);
-    }
-
-    Ok(updated_files.into_iter().collect())
-}
-
-#[allow(dead_code)]
-pub fn sync(
-    remote_name: &str,
-    remote_branch: &str,
-    repo: &Repository,
-) -> Result<Vec<FileDelta>, git2::Error> {
-    let mut remote = repo.find_remote(remote_name)?;
-    let fetch_commit = do_fetch(repo, &[remote_branch], &mut remote)?;
-    let delta = calculate_diff(
-        repo,
-        &repo.reference_to_annotated_commit(&repo.head()?)?,
-        &fetch_commit,
-    );
-    do_merge(repo, remote_branch, fetch_commit)?;
-    delta
-}

backend/server/src/utils/mod.rs

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

client/.gitignore

@@ -1,12 +0,0 @@
-.venv/
-
-.idea/
-
-.DS_store
-
-__pycache__
-
-.cache
-
-content/*
-/content/

client/README.md

@@ -1,30 +0,0 @@
-## Module Structure
-
-```shell
-.
-├── README.md
-├── cli
-├── content
-│   ├── pages
-│   │   └── about
-│   │       └── <static_page>.md
-│   └── posts
-│       └── <year>
-│           └── <identifier>
-│               ├── assets
-│               │   └── <assets>
-│               ├── translate_<lang>.md
-│               └── index.md
-├── requirements.txt
-├── templates
-│   ├── <template>.py
-│   └── ...
-└── utils
-    └── ...
-```
-
-### About `posts`
-
-- Will render to `https://<DOMAIN>/blog/post/<identifier>`.
-- Files under `assets/` (where images etc. located) should be pushed to OSS.
-- For identifiers, use prefix `-` to indicate private (hidden) visibility. EX: `-hello-world`.

client/cli

@@ -1,27 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-
-import rich
-
-from templates.post import BlogPost
-from utils.cache import init_cache
-from utils.index import build_post_idx
-
-
-def main():
-    # if args.new:
-    #     new_post()
-    init_cache()
-    build_post_idx()
-    bp = BlogPost()
-    bp.init()
-
-
-parser = argparse.ArgumentParser()
-parser.add_argument("-n", "--new", help="Create a post with build-in template", type=str)
-args = parser.parse_args(namespace=rich)
-# todo: cli
-
-if __name__ == '__main__':
-    main()

client/requirements.txt

@@ -1,4 +0,0 @@
-rich~=13.9.4
-prompt_toolkit~=3.0.50
-pypinyin~=0.53.0
-python-frontmatter~=1.1.0

client/templates/post.py

@@ -1,88 +0,0 @@
-import uuid
-from datetime import date
-from datetime import datetime as dt
-from typing import Dict, Optional
-
-from templates.utils import Template, create_all_files
-from utils.autocompletion import input_autocompletion, fuzzy_pinyin_matcher
-from utils.cache import get_tags_cache, get_categories_cache
-from utils.lang import eprint, wprint
-
-POST_TEMPLATE = '''
----
-id: {{ id }}
-title: {{ title }}
-subtitle: {{ subtitle }}
-status: {{ status }}
-date: {{ date }}
-update: {{ update }}
-category: {{ category }}
-tags: {{ tags }}
----
-
-WIP
-
-'''
-
-
-def get_title():
-    while True:
-        i = input("title > ")
-        if i.strip() == "":
-            eprint("empty title")
-            continue
-        else:
-            return i.strip()
-
-
-def get_subtitle():
-    return input("subtitle > ")
-
-
-def get_date():
-    while True:
-        d = input("date (YYYY-MM-DD) > ")
-        if d == "":
-            wprint("using today's date")
-            return dt.today().strftime("%Y-%m-%d")
-        else:
-            try:
-                _validate = dt.strptime(d, "%Y-%m-%d")
-                return d
-            except ValueError:
-                eprint("invalid date")
-                continue
-
-
-def get_tags():
-    # todo: multi tags support
-    return input_autocompletion("tags > ", get_tags_cache(), fuzzy_pinyin_matcher)
-
-
-def get_category():
-    while True:
-        i = input_autocompletion("category > ", get_categories_cache(), fuzzy_pinyin_matcher)
-        if i.strip() == "":
-            eprint("empty category")
-            continue
-        else:
-            return i.strip()
-
-
-class BlogPost(Template):
-    WORK_PATH: str = "content/posts/{year}/{identifier}/"
-    ITEMS: Dict[str, Optional[str]] = {"index.md": POST_TEMPLATE, "assets/": None}
-
-    def init(self):
-        year = date.today().year
-
-        index_md = POST_TEMPLATE.format(
-            title=get_title(),
-            subtitle=get_subtitle(),
-            date=get_date(),
-            update=dt.today().strftime("%Y-%m-%d"),
-            tags=get_tags(),
-            category=get_category(),
-            id=uuid.uuid4()
-        )
-        create_all_files(self.WORK_PATH.format(year=year, identifier="test"), self.ITEMS)

client/templates/utils.py

@@ -1,17 +0,0 @@
-import os
-from abc import ABC, abstractmethod
-from typing import Dict, Optional
-
-
-class Template(ABC):
-    @abstractmethod
-    def init(self):
-        pass
-
-
-def create_all_files(relative_work_path: str, items: Dict[str, Optional[str]]):
-    absolute_path = os.path.abspath(relative_work_path)
-    for item in items:
-        if item.endswith("/"):
-            print(absolute_path + item)
-    # todo: create files

client/utils/ansi.py

@@ -1,31 +0,0 @@
-class Ansi:
-    HEADER = '\033[95m'
-    BLUE = '\033[94m'
-    GREEN = '\033[92m'
-    WARNING = '\033[93m'
-    FAIL = '\033[91m'
-    BOLD = '\033[1m'
-    UNDERLINE = '\033[4m'
-    END = '\033[0m'
-
-    def disable(self) -> None:
-        self.HEADER = ''
-        self.BLUE = ''
-        self.GREEN = ''
-        self.WARNING = ''
-        self.FAIL = ''
-        self.BOLD = ''
-        self.UNDERLINE = ''
-        self.END = ''
-
-    @staticmethod
-    def blend(color: list[str], text: str) -> str:
-        return f"{"".join(color)}{text}{Ansi.END}"
-
-    @staticmethod
-    def bold(text: str) -> str:
-        return f"{Ansi.BOLD}{text}{Ansi.END}"
-
-    @staticmethod
-    def underline(text: str) -> str:
-        return f"{Ansi.UNDERLINE}{text}{Ansi.END}"

client/utils/autocompletion.py

@@ -1,46 +0,0 @@
-from collections.abc import Callable
-from typing import List, Iterable
-
-import prompt_toolkit
-from prompt_toolkit.completion import Completer, CompleteEvent, Completion
-from prompt_toolkit.document import Document
-from pypinyin import lazy_pinyin, Style
-
-
-class AutoCompleter(Completer):
-    def __init__(self, candidates: List[str], matching_algorithm: Callable[[str, str], bool]):
-        self.candidates = candidates
-        self.matching_algorithm = matching_algorithm
-
-    def get_completions(self, document: Document, complete_event: CompleteEvent) -> Iterable[Completion]:
-        curr_word = document.text_before_cursor
-        for c in self.candidates:
-            if self.matching_algorithm(curr_word, c):
-                yield Completion(c, start_position=-len(curr_word))
-
-
-def exact_matcher(word: str, candidate: str, case_sensitive: bool = False) -> bool:
-    if case_sensitive:
-        return word == candidate
-    else:
-        return word.lower() == candidate.lower()
-
-
-def fuzzy_matcher(word: str, candidate: str) -> bool:
-    return word.lower() in candidate.lower()
-
-
-def fuzzy_pinyin_matcher(word: str, candidate: str) -> bool:
-    try:
-        word_matcher = ''.join(lazy_pinyin(word, style=Style.NORMAL))
-        candidate_matcher = ''.join(lazy_pinyin(candidate, style=Style.NORMAL))
-        return candidate_matcher.startswith(word_matcher)
-
-    except e:
-        return fuzzy_matcher(word, candidate)
-
-
-def input_autocompletion(prompt: str, candidates: List[str],
-                         matching_algorithm: Callable[[str, str], bool] = exact_matcher) -> str:
-    completer = AutoCompleter(candidates, matching_algorithm)
-    return prompt_toolkit.prompt(prompt, completer=completer, complete_in_thread=True)

client/utils/cache.py

@@ -1,49 +0,0 @@
-import json
-import os
-from typing import TextIO
-
-CACHE_DIR = ".cache"
-ITEMS = {"register": "register.json"}
-
-
-def overwrite_json_file(file: TextIO, json_data: dict):
-    file.seek(0)
-    file.write(json.dumps(json_data, indent=4, ensure_ascii=False))
-    file.truncate()
-
-
-def init_cache():
-    if not os.path.exists(CACHE_DIR):
-        os.makedirs(CACHE_DIR)
-    for item in ITEMS.values():
-        item_path = os.path.join(CACHE_DIR, item)
-        if not os.path.exists(item_path):
-            with open(item_path, 'w') as cache_file:
-                match item:
-                    case "register.json":
-                        overwrite_json_file(cache_file, {})
-                        break
-
-
-def write_tags_cache(tags: list[str]):
-    with open(os.path.join(CACHE_DIR, ITEMS["register"]), 'r+') as tags_cache_file:
-        cache = json.load(tags_cache_file)
-        cache["tags"] = tags
-        overwrite_json_file(tags_cache_file, cache)
-
-
-def write_category_cache(categories: list[str]):
-    with open(os.path.join(CACHE_DIR, ITEMS["register"]), 'r+') as categories_cache_file:
-        cache = json.load(categories_cache_file)
-        cache["categories"] = categories
-        overwrite_json_file(categories_cache_file, cache)
-
-
-def get_tags_cache() -> list[str]:
-    with open(os.path.join(CACHE_DIR, ITEMS["register"]), 'r') as tags_cache_file:
-        return json.load(tags_cache_file)["tags"]
-
-
-def get_categories_cache() -> list[str]:
-    with open(os.path.join(CACHE_DIR, ITEMS["register"]), 'r') as categories_cache_file:
-        return json.load(categories_cache_file)["categories"]

client/utils/index.py

@@ -1,27 +0,0 @@
-import os
-
-import frontmatter
-
-from utils.cache import write_tags_cache, write_category_cache
-from utils.lang import list_exclude
-
-EXCLUDE = [".DS_Store"]
-POSTS_DIR = "content/posts"
-
-
-def build_post_idx():
-    tags = set()
-    categories = set()
-    for year in list_exclude(os.listdir(POSTS_DIR), EXCLUDE):
-        for post_dir in list_exclude(os.listdir(os.path.join(POSTS_DIR, year)), EXCLUDE):
-            target_file = os.path.join(POSTS_DIR, year, post_dir, "index.md")
-            with open(target_file, "r") as f:
-                post = frontmatter.loads(f.read())
-                try:
-                    for tag in post.metadata["tags"]:
-                        tags.add(tag)
-                    categories.add(post.metadata["category"])
-                except KeyError:
-                    print(f"failed to parse {target_file}")
-    write_tags_cache(list(tags))
-    write_category_cache(list(categories))

client/utils/lang.py

@@ -1,13 +0,0 @@
-from utils.ansi import Ansi
-
-
-def list_exclude(source: list, exclude: list):
-    return filter(lambda item: item not in exclude, source)
-
-
-def eprint(msg: str):
-    print(Ansi.blend([Ansi.FAIL], "error: ") + msg)
-
-
-def wprint(msg: str):
-    print(Ansi.blend([Ansi.WARNING], "warn: ") + msg)

container/release/backend.containerfile

@@ -5,6 +5,6 @@ RUN ["cargo", "build", "-r"]
 
 FROM gcr.io/distroless/cc AS production
 ARG ARCH
-COPY --from=builder /app/target/release/server ./server
+COPY --from=builder /app/target/release/api_server ./api_server
 COPY --from=builder /usr/lib/${ARCH}-linux-gnu/libz.so.1 /usr/lib/${ARCH}-linux-gnu/
-ENTRYPOINT ["./server"]
+ENTRYPOINT ["./api_server"]

daemon/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "daemon"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-clap = { version = "4.5.47", features = ["derive"] }
-containerd-client = "0.8.0"
-tokio = { version = "1.45.1", features = ["macros", "rt-multi-thread"] }

daemon/Makefile

@@ -1,13 +0,0 @@
-.PHONY: rebuild
-rebuild:
-	cargo clean
-	cargo build
-
-.PHONY: rebuild-release
-rebuild-release:
-	cargo clean
-	cargo build -r
-
-.PHONY: run
-run:
-	sudo ./target/debug/daemon

daemon/src/actions/mod.rs

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

daemon/src/config/default.json

@@ -1,8 +0,0 @@
-{
-  "images": [
-    {
-      "id": "",
-      "image": ""
-    }
-  ]
-}

daemon/src/main.rs

@@ -1,89 +0,0 @@
-mod actions;
-mod config;
-
-use clap::Parser;
-use containerd_client::tonic::Request;
-use containerd_client::{
-    connect,
-    services::v1::{transfer_client::TransferClient, TransferOptions, TransferRequest},
-    to_any,
-    types::transfer::OciRegistry,
-    types::transfer::{ImageStore, UnpackConfiguration},
-    types::Platform,
-    with_namespace,
-};
-use std::env::consts;
-
-#[derive(Parser, Debug)]
-struct Args {
-    /// containerd namespace
-    #[arg(short, long, default_value = "nocturne")]
-    namespace: String,
-
-    /// containerd socket
-    #[arg(short, long, default_value = "/run/containerd/containerd.sock")]
-    socket: String,
-}
-
-const IMAGE: &str = "docker.io/library/alpine:latest";
-
-#[tokio::main]
-async fn main() {
-    let args = Args::parse();
-
-    let arch = match consts::ARCH {
-        "x86_64" => "amd64",
-        "aarch64" => "arm64",
-        _ => consts::ARCH,
-    };
-
-    dbg!(&args);
-
-    let channel = connect(&args.socket).await.expect("failed to bind socket");
-    let mut client = TransferClient::new(channel.clone());
-
-    let registry = OciRegistry {
-        reference: IMAGE.to_string(),
-        resolver: Default::default(),
-    };
-
-    let platform = Platform {
-        os: "linux".to_string(),
-        architecture: arch.to_string(),
-        variant: "".to_string(),
-        os_version: "".to_string(),
-    };
-
-    let destination = ImageStore {
-        name: IMAGE.to_string(),
-        platforms: vec![platform.clone()],
-        unpacks: vec![UnpackConfiguration {
-            platform: Some(platform),
-            ..Default::default()
-        }],
-        ..Default::default()
-    };
-
-    let anys = to_any(&registry);
-    let anyd = to_any(&destination);
-
-    println!(
-        "Pulling image for linux/{} from source: {:?}",
-        arch, registry
-    );
-
-    let request = TransferRequest {
-        source: Some(anys),
-        destination: Some(anyd),
-        options: Some(TransferOptions {
-            ..Default::default()
-        }),
-    };
-    // let request = Request::new(request);
-    let req = with_namespace!(request, args.namespace);
-
-    client
-        .transfer(req)
-        .await
-        .expect("unable to transfer image");
-}

dev.compose.yaml

@@ -31,6 +31,6 @@ services:
   postgres:
     image: postgres:16.3
     ports:
-      - "5432:5432"
+      - 5432:5432
     env_file:
       - ./container/dev/.env

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/Makefile

@@ -1,8 +0,0 @@
-
-.PHONY:all
-all: standalone
-
-.PHONY: standalone
-standalone:
-	npm run build
-	cp -r public .next/standalone/ && cp -r .next/static .next/standalone/.next/

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;