git(global) create release branch

feat(lab) add link to lab
fix(blog::post::footer) remove update_date section if undefined
2026-10-17 18:36:21 +00:00 · 2025-04-13 03:52:03 -07:00 · 2024-12-10 04:00:57 -08:00 · 2024-12-10 04:00:10 -08:00 · 2024-12-08 22:25:47 -08:00 · 2024-12-01 02:39:00 -08:00
117 changed files with 4029 additions and 469 deletions
@@ -1,2 +1,19 @@
-BLOG_ENDPOINT=https://raw.githubusercontents.com/lumither/blog-posts/master
+# postgres settings
-; use mirror
+DB_HOST=localhost
 DB_PORT=5432
 #POSTGRES_PASSWORD=
 POSTGRES_USER=nocturne
 POSTGRES_DB=nocturne
 POSTGRES_HOST=postgres
 # backend settings
 #GIT_WORK_DIR=../blog_posts_git
 #LOG_ROOT_DIR=/var/log/nocturne
 #BLOG_ENDPOINT=https://github.com/Lumither/blog-posts.git
 BLOG_GIT_URL=https://github.com/Lumither/blog-posts.git
 WORK_DIR=/nocturne
 #BACKEND_PORT=3001
 # frontend settings
 API_LOCAL_URL=http://backend:3001
 API_REMOTE_URL=https://lumither.com/api
@@ -1,42 +1,10 @@
-# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+# confidential
 .env.*
 /container/*/.env
-# dependencies
+# IDE related
 /node_modules
 /.pnp
 .pnp.js
 .yarn/install-state.gz
 # testing
 /coverage
 # next.js
 /.next/
 /out/
 # production
 /build
 # misc
 .DS_Store
 *.pem
 # debug
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 # local env files
 .env*.local
 # vercel
 .vercel
 # typescript
 *.tsbuildinfo
 next-env.d.ts
 # bun
 bun.lockb
 # ide related
 .idea
 .vscode
 # exclude post repo
 /blog_posts_git
@@ -0,0 +1,16 @@
 ARCH := $(shell uname -m)
 ifeq ($(ARCH), arm64)
    ARCH := aarch64
 endif
 all: release
 release:
 	docker compose -f prod.compose.yaml build --build-arg ARCH=$(ARCH)
 dev:
 	docker-compose -f dev.compose.yaml up --build
 clean:
 	docker-compose -f prod.compose.yaml -f dev.compose.yaml rm -fsv
@@ -1,83 +1,34 @@
-# This branch was deprecated.
+# `Nocturne: personal website & CMS`
-In the initial plan of the blog, `raw.githubusercontent.com/<usr>/<branch>/<path_to_file>` (or any other git server)
+> This is the last working version
 was used as the cdn for the blog website, which also come with VCS without effort.
-The idea is to build a separate repo that will be served as a database in ideal blog system structure, and all the
+This is the code repo of my personal website, and [here](https://github.com/Lumither/blog-posts/) is the link of the
-functionality related to CMS will be hosted by cloudflare worker.
+content repo.
-```bash
+Powered by Next.js and Rust, built with passion and love
 master > tree
 .
 ├── idx.json
 └── posts
    ├── another_article.md
    ├── hello_world.md
    └── idx.json
-2 directories, 3 files
+*will add more here in the future
 ```
-This is an example of [db repo](https://github.com/Lumither/blog-posts.git).
+## Nav:
-```bash
+    <todo>
-master > cat idx.json
+## Todos:
 {
    "idx": [
        {
            "type": "dir",
            "name": "posts"
        }
    ]
 }
 master > cat ./posts/idx.json
 {
    "idx": [
        {
            "type": "md",
            "name": "another_article.md",
            "meta": {
                "title": "another_article!",
                "desc": "test",
                "tag": ["blog", "test", "dev"]
            }
        },
        {
            "type": "md",
            "name": "hello_world.md",
            "meta": {
                "title": "Hello World!",
                "desc": "test",
                "tag": ["blog", "test", "dev"]
            }
        }
    ]
 }
 ```
-These are examples of `idx.json`. They were designed to be placed at any layer of the directory, and used
+### Backend
 to accelerate the client side browsing. The following is an easy [implementation](/app/blog/fetch_posts.ts) of using `idx.json` at `/posts` 
 to get a list of blog posts.
-```ts
+- [ ] Add: log system
-export default async function fetch_posts(url: string): Promise<Result<JSON[], Error>> {
+- [ ] Add: search api
-    const response = await fetch(`${ url }/posts/idx.json`);
+- [ ] Add: tag filter (api)
-    if (!response.ok) {
+- [ ] Abandon: UUID mechanism
-        return {
+- [ ] Fix: db connection issue
-            ok: false,
+
-            error: new Error(response.statusText)
+### Frontend
-        };
+
-    }
+- [ ] Page: Home
-    const res = await response.json();
+- [ ] Page: About
-    const posts = res['idx'].filter((posts: { type: string }) => posts.type === 'md');
+- [ ] Page: Tags
-    return {
+- [ ] Page: Archive
-        ok: true,
+- [ ] Page: Search
-        value: posts
+- [ ] Add: Right sidebar
    };
 }
 ```
 The approach work impressively well, thanks for the globe services of GitHub lol, but eventually the plan was changed
 due to ethical reasons and possibility of breaking GitHub's EULA. Plus, the functionality of the blog site might be constrained due to
 Cloudflare worker's CPU time limitations, considering the existence of potential resource-intense work such as on-site searching and analytics.
@@ -1,9 +0,0 @@
 import React from 'react';
 function About() {
    return (
        <div></div>
    );
 }
 export default About;
@@ -1,33 +0,0 @@
 import React from 'react';
 import Link from 'next/link';
 import { Card, CardBody, CardHeader } from '@nextui-org/card';
 import { Divider } from '@nextui-org/react';
 type Props = {
    post: JSON
 }
 function BlogPostCard({ post }: Props) {
    const name = (post as any)['name'];
    const { title, desc } = (post as any)['meta'] as { title: string, desc: string };
    return (
        <div>
            {/*todo: to be update*/ }
            {/*<Link href={ `/blog/${ name }` }>*/}
                <Card>
                    <CardHeader>
                        <p className={ 'font-bold' }>{ title }</p>
                    </CardHeader>
                    <Divider />
                    <CardBody>
                        { desc }
                    </CardBody>
                </Card>
            {/*</Link>*/}
        </div>
    );
 }
 export default BlogPostCard;
@@ -1,19 +0,0 @@
 import { Result } from '@/app/public/type/Result';
 export default async function fetch_posts(url: string): Promise<Result<JSON[], Error>> {
    const response = await fetch(`${ url }/posts/idx.json`);
    if (!response.ok) {
        return {
            ok: false,
            error: new Error(response.statusText)
        };
    }
    const res = await response.json();
    const posts = res['idx'].filter((posts: { type: string }) => posts.type === 'md');
    return {
        ok: true,
        value: posts
    };
 }
@@ -1,28 +0,0 @@
 import React from 'react';
 import fetch_posts from '@/app/blog/fetch_posts';
 import BlogPostCard from '@/app/blog/BlogPostCard';
 async function Blog() {
    const res = await fetch_posts(process.env.BLOG_ENDPOINT!);
    if (!res.ok) {
        console.log(res.error);
        return;
    }
    const posts = res.value;
    // console.log(posts);
    return (
        // blog list
        <ul className={ 'flex flex-col items-center w-full max-w-[1024px]' }>
            { posts.map((post, key) => (
                <li key={ key } className={ 'my-3.5 mx-7 w-[80%]' }>
                    <BlogPostCard post={ post } />
                </li>)
            ) }
        </ul>
    );
 }
 export default Blog;
@@ -1,3 +0,0 @@
@tailwind base;
@tailwind components;
@tailwind utilities;
@@ -1,30 +0,0 @@
 import type { Metadata } from 'next';
 import { Inter } from 'next/font/google';
 import './globals.css';
 import React from 'react';
 import { ThemeProvider as NextThemesProvider } from 'next-themes';
 import Navbar from '@/components/Navbar';
 const inter = Inter({ subsets: [ 'latin' ] });
 export const metadata: Metadata = {
    title: 'Lumither\'s site',
    description: 'a small corner on internet'
 };
 export default function RootLayout({
    children
 }: Readonly<{
    children: React.ReactNode;
 }>) {
    return (
        <html lang="en" suppressHydrationWarning>
        <body className={ inter.className }>
        <NextThemesProvider attribute="class" defaultTheme="dark">
            <Navbar />
            { children }
        </NextThemesProvider>
        </body>
        </html>
    );
 }
@@ -1,7 +0,0 @@
 export default function Home() {
    return (
        <main>
            {/*<ThemeSwitcher />*/ }
        </main>
    );
 }
@@ -0,0 +1,3 @@
 /target
 /Cargo.lock
@@ -0,0 +1,18 @@
 ### Rust template
 # Generated by Cargo
 # will have compiled files and executables
 debug/
 target/
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
 Cargo.lock
 # These are backup files generated by rustfmt
 **/*.rs.bk
 # MSVC Windows builds of rustc generate these, which store debugging information
 *.pdb
 .env.local
@@ -0,0 +1,8 @@
 [workspace]
 resolver = "2"
 members = [
    "api_server",
    "constants",
    "macros",
    "markdown",
 ]
@@ -0,0 +1,25 @@
 [package]
 name = "api_server"
 version = "0.1.0"
 edition = "2021"
 [dependencies]
 macros = { path = "../macros" }
 constants = { path = "../constants" }
 markdown = { path = "../markdown" }
 chrono = { version = "0.4.38", features = ["serde", "alloc"] }
 tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.18", features = ["env-filter", "fmt"] }
 tracing-appender = "0.2.3"
 dotenv = "0.15.0"
 dirs = "5.0.1"
 tokio = { version = "1.40.0", features = ["full"] }
 sqlx = { version = "0.8.2", features = ["runtime-tokio", "tls-native-tls", "postgres", "chrono", "uuid"] }
 axum = { version = "0.7.5", features = ["macros"] }
 serde = { version = "1.0.199", features = ["derive"] }
 serde_json = "1.0.128"
 uuid = { version = "1.10.0", features = ["v4", "fast-rng", "serde"] }
 futures = { version = "0.3.30", features = ["executor"] }
 cron = "0.13.0"
 git2 = "0.19.0"
 thiserror = "2.0.3"
@@ -0,0 +1,26 @@
 use constants::blog::PAGE_SIZE;
 use axum::extract::State;
 use axum::Json;
 use serde_json::{json, Value};
 use sqlx::{query, PgPool, Row};
 use tracing::error;
 pub async fn get_page_count(
    State(db_connection): State<PgPool>,
 ) -> Result<Json<Value>, Json<Value>> {
    match query("select cast(ceil(count(*) / $1) as integer) as res from post")
        .bind(PAGE_SIZE as f32)
        .fetch_one(&db_connection)
        .await
    {
        Ok(res) => {
            let res: i32 = res.get("res");
            Ok(Json::from(json!({"res": res})))
        }
        Err(e) => {
            error!("Failed to get blog page count: {}", e.to_string());
            Err(Json::from(json!({"error": e.to_string()})))
        }
    }
 }
@@ -0,0 +1,153 @@
 use axum::{
    extract::{Path, State},
    http::StatusCode,
    Json,
 };
 use serde_json::{json, Value};
 use sqlx::{query, Error, PgPool, Row};
 use std::str::FromStr;
 use tracing::error;
 use uuid::Uuid;
 pub async fn get_post(
    State(db_connection): State<PgPool>,
    Path(post_id): Path<String>,
 ) -> Result<Json<Value>, (StatusCode, Json<Value>)> {
    let post_id = match Uuid::from_str(post_id.as_str()) {
        Ok(id) => id,
        Err(e) => {
            error!(
                "Failed to parse UUID <{}>: {}",
                post_id.as_str(),
                e.to_string()
            );
            return Err((
                StatusCode::BAD_REQUEST,
                Json::from(json!(("error", e.to_string()))),
            ));
        }
    };
    let post = match query(
        r#"
 SELECT jsonb_strip_nulls(to_jsonb(t.*)) - 'post_id' AS post
 FROM post t
 WHERE post_id = $1;
 "#,
    )
    .bind(post_id)
    .fetch_one(&db_connection)
    .await
    {
        Ok(value) => value.get::<Value, _>("post"),
        Err(e) => {
            error!(
                "Database error on Reading `base post information` from table `post`: <{}>: {}",
                post_id.to_string(),
                e.to_string()
            );
            return match e {
                Error::RowNotFound => Err((
                    StatusCode::BAD_REQUEST,
                    Json::from(json!({"error": e.to_string()})),
                )),
                _ => Err((
                    StatusCode::INTERNAL_SERVER_ERROR,
                    Json::from(json!({"error": e.to_string()})),
                )),
            };
        }
    };
    let tags: Vec<_> = match query("SELECT tag FROM Tag WHERE post_id = $1;")
        .bind(post_id)
        .fetch_all(&db_connection)
        .await
    {
        Ok(tags) => tags.iter().map(|tag| tag.get::<String, _>("tag")).collect(),
        Err(e) => {
            error!("Database query error :{}", e.to_string());
            return Err((
                StatusCode::INTERNAL_SERVER_ERROR,
                Json::from(json!({"error": e.to_string()})),
            ));
        }
    };
    let meta = match query(
        r#"
 SELECT jsonb_strip_nulls(to_jsonb(t.*)) - 'post_id' AS meta
 FROM meta t
 WHERE post_id = $1;
        "#,
    )
    .bind(post_id)
    .fetch_one(&db_connection)
    .await
    {
        Ok(value) => value.get::<Value, _>("meta"),
        Err(e) => {
            error!(
                "Database error on Reading `{}` from table `{}`: <{}>: {}",
                "post meta data",
                "meta",
                post_id.to_string(),
                e.to_string()
            );
            return Err((
                StatusCode::INTERNAL_SERVER_ERROR,
                Json::from(json!({"error": e.to_string()})),
            ));
        }
    };
    let adjacent = match query(r"
 WITH target_post AS (SELECT t.date FROM meta t WHERE post_id = $1),
     prev AS (SELECT post_id, t.title, t.sub_title, t.header_img
              FROM meta t
              WHERE t.date < (SELECT date FROM target_post)
              ORDER BY t.date DESC
              LIMIT 1),
     next AS (SELECT post_id, t.title, t.sub_title, t.header_img
              FROM meta t
              WHERE t.date > (SELECT date FROM target_post)
              ORDER BY t.date
              LIMIT 1)
 SELECT json_strip_nulls(json_build_object(
        'prev',
        (SELECT json_build_object('id', post_id, 'title', title, 'sub_title', sub_title, 'header_img', header_img)
         FROM prev),
        'next',
        (SELECT json_build_object('id', post_id, 'title', title, 'sub_title', sub_title, 'header_img', header_img)
         FROM next)
                        )) AS result;
 "
    )
        .bind(post_id)
        .fetch_one(&db_connection)
        .await
    {
        Ok(res) => {res.get::<Value, _>("result")}
        Err(e) => {
            error!(
                "Database error on Reading `{}` from table `{}`: <{}>: {}",
                "adjoint posts data",
                "meta",
                post_id.to_string(),
                e.to_string()
            );
            return Err((
                StatusCode::INTERNAL_SERVER_ERROR,
                Json::from(json!({"error": e.to_string()})),
            ));
        }
    };
    let mut res = post.as_object().unwrap().to_owned();
    res.insert("tags".to_string(), tags.into());
    res.insert("meta".to_string(), meta);
    res.insert("adj".to_string(), adjacent);
    Ok(Json::from(json!(res)))
 }
@@ -0,0 +1,130 @@
 use std::error::Error;
 use constants::blog::PAGE_SIZE;
 use axum::{extract::Query, extract::State, http::StatusCode, Json};
 use chrono::{DateTime, Utc};
 use futures::future::join_all;
 use serde::Deserialize;
 use serde_json::{json, Map, Value};
 use sqlx::{postgres::PgRow, query, PgPool, Row};
 use tracing::error;
 use uuid::Uuid;
 #[derive(Deserialize)]
 pub struct Params {
    page: Option<u32>,
 }
 #[axum::debug_handler]
 pub async fn get_post_list(
    State(db_connection): State<PgPool>,
    Query(params): Query<Params>,
 ) -> Result<Json<Value>, (StatusCode, Json<Value>)> {
    let search_param_page = params.page.unwrap_or(1);
    if search_param_page < 1 {
        return Err((
            StatusCode::BAD_REQUEST,
            Json::from(json!({"error": "`page` should be greater than 0"})),
        ));
    }
    let offset = PAGE_SIZE * (search_param_page - 1);
    let post_list = sqlx::query("SELECT * FROM post ORDER BY first_update DESC LIMIT $1 OFFSET $2")
        .bind(PAGE_SIZE as i32)
        .bind(offset as i32)
        .fetch_all(&db_connection)
        .await;
    let post_list = match post_list {
        Ok(post_list) => post_list,
        Err(e) => {
            error!(
                "Database query error on fetching post list: {}",
                e.to_string()
            );
            return Err((
                StatusCode::INTERNAL_SERVER_ERROR,
                Json::from(json!({"error": e.to_string()})),
            ));
        }
    };
    let mut res = Vec::new();
    let posts: Vec<_> = post_list
        .into_iter()
        .map(|post| async { analyze_post(&db_connection, post).await })
        .collect();
    let posts = join_all(posts).await;
    for post in posts {
        match post {
            Ok(p) => res.push(p),
            Err(e) => {
                return Err((
                    StatusCode::INTERNAL_SERVER_ERROR,
                    Json::from(json!(("error", e.to_string()))),
                ))
            }
        }
    }
    // res.insert("posts".to_string(), Value::from(posts));
    Ok(Json::from(Value::from(res)))
 }
 async fn analyze_post(db_connection: &PgPool, post: PgRow) -> Result<Value, Box<dyn Error + Send>> {
    let post_id: Uuid = post.get("post_id");
    let tags = fetch_post_tags(db_connection, post_id).await;
    let meta = fetch_post_meta(db_connection, post_id).await.unwrap();
    let header_img = meta.get("header_img");
    let last_update = meta.get("last_update");
    Ok(json!({
        "post_id": post_id.to_string(),
        "title": post.get::<String, _>("title"),
        "category": post.get::<String, _>("category"),
        "header_img": header_img,
        "sub_title": post.get::<String, _>("sub_title"),
        "summary": post.get::<String, _>("summary"),
        "last_update": last_update,
        "first_update": post.get::<DateTime<Utc>, _>("first_update"),
        "tags": tags,
    }))
 }
 async fn fetch_post_meta(db_connection: &PgPool, post_id: Uuid) -> Option<Value> {
    match query(
        r#"
 SELECT jsonb_strip_nulls(to_jsonb(t.*)) - 'post_id' AS meta
 FROM meta t
 WHERE post_id = $1;
        "#,
    )
    .bind(post_id)
    .fetch_one(db_connection)
    .await
    {
        Ok(value) => Some(value.get::<Value, _>("meta")),
        Err(e) => {
            error!(
                "Database error on Reading `{}` from table `{}`: <{}>: {}",
                "post meta data",
                "meta",
                post_id.to_string(),
                e.to_string()
            );
            None
        }
    }
 }
 async fn fetch_post_tags(db_connection: &PgPool, post_id: Uuid) -> Vec<String> {
    match query("SELECT tag FROM Tag WHERE post_id = $1")
        .bind(post_id)
        .fetch_all(db_connection)
        .await
    {
        Ok(res) => res.iter().map(|tag| tag.get::<String, _>("tag")).collect(),
        Err(_) => vec![],
    }
 }
@@ -0,0 +1,3 @@
 pub mod get_page_count;
 pub mod get_post;
 pub mod get_post_list;
@@ -0,0 +1,49 @@
 use thiserror::Error;
 #[derive(Error, Debug)]
 pub enum PostIdxError {
    #[error("missing essential field `{}` for file `{}`", field, filename)]
    MissingField { field: String, filename: String },
    #[error(
        "invalid field `{}` for file `{}`, <{}>: {}",
        field_name,
        filename,
        err_field,
        msg
    )]
    InvalidField {
        field_name: String,
        err_field: String,
        filename: String,
        msg: String,
    },
    #[error(
        "database error on writing `{}` to table `{}`: <{}>: {}",
        data_desc,
        db_table,
        id,
        msg
    )]
    DBWriteFailure {
        data_desc: String,
        db_table: String,
        id: String,
        msg: String,
    },
    #[error(
        "Database error on Reading `{}` from table `{}`: <{}>: {}",
        data_desc,
        db_table,
        id,
        msg
    )]
    DBReadFailure {
        data_desc: String,
        db_table: String,
        id: String,
        msg: String,
    },
 }
@@ -0,0 +1,351 @@
 use std::error::Error;
 use std::path::Path;
 use crate::blog::cron::check_update::utils::get_md_file_basename;
 use crate::blog::cron::check_update::{error::PostIdxError, utils::parse_date};
 use markdown::MdFile;
 use sqlx::{query, PgPool, Pool, Postgres, Row};
 use tokio::runtime::Runtime;
 use tracing::{info, warn};
 async fn base(db_connection: &PgPool, post: &MdFile) -> Result<(), PostIdxError> {
    let post_id = post.file_id;
    let title = match post.meta.get("title") {
        None => {
            return Err(PostIdxError::MissingField {
                field: "title".to_string(),
                filename: post.filename.clone(),
            })
        }
        Some(title) => title.as_str().unwrap_or_else(|| {
            warn!("invalid title for `{}`", &post.filename);
            "invalid title"
        }),
    };
    let sub_title = post
        .meta
        .get("sub_title")
        .and_then(|v| v.as_str())
        .unwrap_or("");
    let summary = post
        .meta
        .get("summary")
        .and_then(|v| v.as_str())
        .unwrap_or("");
    let content = post.content.as_str();
    let category = match post.meta.get("category") {
        None => {
            return Err(PostIdxError::MissingField {
                field: "category".to_string(),
                filename: post.filename.clone(),
            })
        }
        Some(title) => title.as_str().unwrap_or_else(|| {
            warn!("invalid category for `{}`", &post.filename);
            "invalid category"
        }),
    };
    let last_update = {
        if let Some(last_update) = post.meta.get("last_update") {
            match parse_date(last_update.as_str().unwrap()) {
                Ok(date) => Some(date),
                Err(e) => {
                    return Err(PostIdxError::InvalidField {
                        field_name: "last_update".to_string(),
                        err_field: last_update.to_string(),
                        filename: post.filename.clone(),
                        msg: e.to_string(),
                    })
                }
            }
        } else {
            None
        }
    };
    let first_update = match post.meta.get("date") {
        None => {
            return Err(PostIdxError::MissingField {
                field: "date".to_string(),
                filename: post.filename.clone(),
            })
        }
        Some(first_update) => match parse_date(first_update.as_str().unwrap()) {
            Ok(date) => date,
            Err(e) => {
                return Err(PostIdxError::InvalidField {
                    field_name: "date".to_string(),
                    err_field: first_update.to_string(),
                    filename: post.filename.clone(),
                    msg: e.to_string(),
                })
            }
        },
    };
    let filename = get_md_file_basename(&post.filename);
    if let Err(e) = query(
        r##"
 INSERT INTO Post (post_id, title, summary, content, last_update, first_update, sub_title, category, filename)
 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
 ON CONFLICT (post_id) DO
 UPDATE SET
    title = EXCLUDED.title,
    summary = EXCLUDED.summary,
    content = EXCLUDED.content,
    last_update = EXCLUDED.last_update,
    first_update = EXCLUDED.first_update,
    sub_title = EXCLUDED.sub_title,
    category = EXCLUDED.category,
    filename = EXCLUDED.filename;
        "##,
    )
        .bind(post_id)
        .bind(title)
        .bind(summary)
        .bind(content)
        .bind(last_update)
        .bind(first_update)
        .bind(sub_title)
        .bind(category)
        .bind(filename)
        .execute(db_connection)
        .await
    {
        return Err(
            PostIdxError::DBWriteFailure {
                data_desc: "post base information".to_string(),
                db_table: "Post".to_string(),
                id: post_id.to_string(),
                msg: e.to_string(),
            }
        );
    }
    Ok(())
 }
 async fn tag(db_connection: &PgPool, post: &MdFile) -> Result<(), PostIdxError> {
    if let Some(tags_string) = post.meta.get("tags").to_owned() {
        let tags = match tags_string.as_array().map(|vec| {
            vec.iter()
                .map(|val| val.as_str().unwrap())
                .collect::<Vec<_>>()
        }) {
            None => {
                return Err(PostIdxError::MissingField {
                    field: "tags".to_string(),
                    filename: post.filename.clone(),
                })
            }
            Some(val) => val,
        };
        let post_id = post.file_id;
        // remove old record
        if let Err(e) = query("DELETE FROM Tag WHERE post_id = $1")
            .bind(post_id)
            .execute(db_connection)
            .await
        {
            return Err(PostIdxError::DBWriteFailure {
                data_desc: "post tag information".to_string(),
                db_table: "Tag".to_string(),
                id: post_id.to_string(),
                msg: e.to_string(),
            });
        }
        // add new record
        for tag in tags {
            match query("INSERT INTO Tag VALUES ($1, $2);")
                .bind(post_id)
                .bind(tag)
                .execute(db_connection)
                .await
            {
                Ok(_) => {}
                Err(e) => {
                    return Err(PostIdxError::DBWriteFailure {
                        data_desc: "post tag information".to_string(),
                        db_table: "Tag".to_string(),
                        id: post_id.to_string(),
                        msg: e.to_string(),
                    })
                }
            }
        }
    }
    Ok(())
 }
 async fn hash(db_connection: &PgPool, post: &MdFile) -> Result<bool, PostIdxError> {
    let base64_form = post.hash.clone();
    match query("SELECT hash FROM Hash WHERE post_id = $1")
        .bind(post.file_id)
        .fetch_optional(db_connection)
        .await
    {
        Ok(row) => {
            let db_record: String = match row {
                None => "".to_string(),
                Some(row) => row.try_get("hash").unwrap_or("".to_string()),
            };
            if base64_form == db_record {
                Ok(false)
            } else {
                if let Err(e) = query(
                    r#"
 INSERT INTO Hash (post_id, hash) VALUES ($1, $2)
    ON CONFLICT (post_id) DO UPDATE SET hash = EXCLUDED.hash"#,
                )
                .bind(post.file_id)
                .bind(&base64_form)
                .execute(db_connection)
                .await
                {
                    return Err(PostIdxError::DBWriteFailure {
                        data_desc: "post hash".to_string(),
                        db_table: "Hash".to_string(),
                        id: post.file_id.to_string(),
                        msg: e.to_string(),
                    });
                }
                Ok(true)
            }
        }
        Err(e) => Err(PostIdxError::DBReadFailure {
            data_desc: "post hash".to_string(),
            db_table: "Hash".to_string(),
            id: post.file_id.to_string(),
            msg: e.to_string(),
        }),
    }
 }
 async fn meta(db_connection: &PgPool, post: &MdFile) -> Result<(), PostIdxError> {
    if let Err(e) = query(
        // todo: sanitization
        format!(
            r#"
 DO
 $$
    DECLARE
        _post_id        UUID  := '{}';
        _meta_cols      JSONB := '{}';
        _exists         BOOLEAN;
        _col_name       TEXT;
        _col_value      TEXT;
        _sql            TEXT;
        _insert_columns TEXT  := 'post_id';
        _insert_values  TEXT  := quote_literal(_post_id);
        _update_set     TEXT  := '';
        _blacklist      TEXT[] := ARRAY['tags'];
    BEGIN
        SELECT EXISTS(SELECT 1 FROM meta WHERE post_id = _post_id) INTO _exists;
        FOR _col_name, _col_value IN SELECT key, value FROM jsonb_each_text(_meta_cols)
            LOOP
                IF _col_name = ANY(_blacklist) THEN
                    CONTINUE;
                END IF;
                IF NOT EXISTS (SELECT 1
                               FROM information_schema.columns
                               WHERE table_name = 'meta'
                                 AND column_name = _col_name
                                 -- may change in the future
                                 AND table_schema = 'public') THEN
                    _sql := 'ALTER TABLE meta ADD COLUMN ' || quote_ident(_col_name) || ' TEXT';
                    EXECUTE _sql;
                END IF;
                _insert_columns := _insert_columns || ', ' || quote_ident(_col_name);
                _insert_values := _insert_values || ', ' || quote_literal(_col_value);
                _update_set := _update_set || ', ' || quote_ident(_col_name) || ' = ' || quote_literal(_col_value);
            END LOOP;
        _update_set := substring(_update_set FROM 3);
        IF _exists THEN
            _sql := 'UPDATE meta SET ' || _update_set || ' WHERE post_id = ' || quote_literal(_post_id);
            EXECUTE _sql;
        ELSE
            _sql := 'INSERT INTO meta (' || _insert_columns || ') VALUES (' || _insert_values || ')';
            EXECUTE _sql;
        END IF;
    END;
 $$ LANGUAGE plpgsql;
        "#, post.file_id.to_string().as_str(), post.meta
        ).as_str()
    )
        .execute(db_connection)
        .await {
        Err(PostIdxError::DBWriteFailure {
            data_desc: "post meta data".to_string(),
            db_table: "Meta".to_string(),
            id: post.file_id.to_string(),
            msg: e.to_string(),
        })
    } else {
        Ok(())
    }
 }
 pub async fn index_file(path: &Path, db_conn: &Pool<Postgres>) -> Result<(), Box<dyn Error>> {
    let md_file = MdFile::from_file(path)?;
    async fn trail(db_conn: &Pool<Postgres>, md_file: &MdFile) -> Result<(), PostIdxError> {
        base(db_conn, md_file).await?;
        tag(db_conn, md_file).await?;
        meta(db_conn, md_file).await?;
        hash(db_conn, md_file).await.map(|_| ())
    }
    let mut cnt = 5;
    while let Err(e) = trail(db_conn, &md_file).await {
        match e {
            PostIdxError::DBWriteFailure { .. } => {
                cnt -= 1;
            }
            PostIdxError::DBReadFailure { .. } => {
                cnt -= 1;
            }
            _ => return Err(e.into()),
        }
        if cnt <= 0 {
            return Err(e.into());
        }
    }
    info!("indexed markdown file: {}", path.display());
    Ok(())
 }
 pub fn drop_index(file_basename: &str, db_conn: &Pool<Postgres>) -> Result<(), Box<dyn Error>> {
    let rt = Runtime::new().unwrap();
    rt.block_on(async {
        if let Err(e) = query(
            r#"
 WITH deleted_post AS (
    DELETE FROM post
    WHERE id = (SELECT id FROM post WHERE filename = $1)
    RETURNING id
 )
 DELETE FROM tag WHERE post_id IN (SELECT id FROM deleted_post);
 DELETE FROM meta WHERE post_id IN (SELECT id FROM deleted_post);
 DELETE FROM hash WHERE post_id IN (SELECT id FROM deleted_post);
    "#,
        )
        .bind(file_basename)
        .execute(db_conn)
        .await
        {
            Err(Box::from(
                format!("failed to drop index: {}", e).to_string(),
            ))
        } else {
            Ok(())
        }
    })
 }
@@ -0,0 +1,146 @@
 use std::env;
 use std::fs::remove_dir_all;
 use std::path::{Path, PathBuf};
 use crate::{
    blog::cron::check_update::{
        index::drop_index,
        utils::{expand_path, get_md_file_basename, index_files, search_md},
    },
    utils::git,
 };
 use constants::config::general::{default_value, var_name};
 use macros::panic_with_log;
 use git2::{Delta, Repository};
 use sqlx::{Pool, Postgres};
 use tracing::{error, info, warn, Level};
 mod error;
 mod index;
 mod utils;
 pub fn task(db_connection: &Pool<Postgres>) {
    // init
    let git_work_dir = {
        let path = if let Ok(default_log_path) = env::var(var_name::WORK_DIR) {
            expand_path(default_log_path)
        } else {
            let fallback_path = expand_path(default_value::WORK_DIR.to_string());
            warn!(
                "unset env var `{}`, using default path: {}/blog_git",
                var_name::WORK_DIR,
                fallback_path
            );
            fallback_path
        };
        Path::new(&path).join("blog_git")
    };
    // clone & check update
    let git_url = match env::var(var_name::BLOG_GIT_URL) {
        Ok(url) => url,
        Err(e) => {
            panic_with_log!(
                Level::ERROR,
                "failed to read `{}`: {}",
                var_name::BLOG_GIT_URL,
                e
            )
        }
    };
    let git_remote_name = env::var(var_name::BLOG_GIT_REMOTE_NAME)
        .unwrap_or(default_value::BLOG_GIT_REMOTE_NAME.to_string());
    let git_remote_branch = env::var(var_name::BLOG_GIT_REMOTE_BRANCH)
        .unwrap_or(default_value::BLOG_GIT_REMOTE_BRANCH.to_string());
    match Repository::open(&git_work_dir) {
        Ok(repo) => {
            // prevent git remote url mismatch (clean cache)
            match repo.find_remote(&git_remote_name) {
                Ok(remote) => {
                    if remote.url().is_some_and(|url| url != git_url) {
                        remove_dir_all(&git_work_dir).unwrap();
                        warn!("blog content git({}) url mismatch, reinitialized", &git_url);
                        return;
                    }
                }
                Err(e) => {
                    remove_dir_all(&git_work_dir).unwrap();
                    error!(
                        "unexpected error on indexing blog content git({}), reinitialized: {}",
                        &git_url, e
                    );
                }
            }
            match git::sync(&git_remote_name, &git_remote_branch, &repo) {
                Ok(updates) => {
                    if !updates.is_empty() {
                        // incremental update
                        info!(
                            "blog content git({}) update detected: {:?}",
                            &git_url, updates
                        );
                        let mut update_md: Vec<PathBuf> = vec![];
                        for update in updates {
                            if [Delta::Deleted, Delta::Untracked].contains(&update.status) {
                                if let Some(path) = &update.old_path {
                                    if drop_index(
                                        &get_md_file_basename(
                                            path.file_name().unwrap().to_str().unwrap(),
                                        ),
                                        db_connection,
                                    )
                                    .is_ok()
                                    {
                                        info!(
                                            "blog content git({}) file `{}` is detected as deleted/untracked, index dropped",
                                            &git_url,
                                            &path.display()
                                        );
                                    } else {
                                        error!(
                                            "blog content git({}) file `{}` is detected as deleted/untracked, failed to drop index",
                                            &git_url,
                                            &path.display()
                                        )
                                    }
                                }
                            } else if let Some(path) = &update.new_path {
                                if path.components().any(|comp| comp.as_os_str() == "posts")
                                    && path.extension().is_some_and(|ext| ext == "md")
                                {
                                    update_md.push(path.to_path_buf());
                                }
                            }
                        }
                        index_files(&update_md, db_connection);
                    }
                }
                Err(e) => {
                    error!(
                        "failed to sync blog content git({}) updates: {}",
                        &git_url, e
                    );
                }
            }
        }
        Err(_) => {
            match Repository::clone(&git_url, &git_work_dir) {
                Ok(_repo) => {
                    // full repo index
                    let files = search_md(git_work_dir.join("posts"));
                    index_files(&files, db_connection);
                }
                Err(e) => {
                    error!("failed to clone blog content git({}): {}", &git_url, e);
                }
            }
        }
    };
 }
@@ -0,0 +1,86 @@
 use dirs::home_dir;
 use std::path::PathBuf;
 use crate::blog::cron::check_update::index::index_file;
 use chrono::{DateTime, FixedOffset, ParseResult};
 use constants::config::general::{default_value, var_name};
 use constants::time::DEFAULT_DATE_FORMAT;
 use futures::executor::block_on;
 use futures::future::join_all;
 use sqlx::{Pool, Postgres};
 use tokio::runtime::Runtime;
 use tokio::spawn;
 use tracing::{error, warn};
 pub fn search_md(entry: PathBuf) -> Vec<PathBuf> {
    if entry.ends_with(".git") {
        return vec![];
    }
    if entry.is_dir() {
        if let Ok(files) = entry.read_dir() {
            files
                .flat_map(|file| {
                    let file_path = file.unwrap().path();
                    search_md(file_path)
                })
                .collect()
        } else {
            vec![]
        }
    } else if entry.extension().is_some_and(|ext| ext == "md") {
        vec![entry]
    } else {
        vec![]
    }
 }
 pub fn index_files(files: &[PathBuf], db_conn: &Pool<Postgres>) {
    let rt = Runtime::new().unwrap();
    rt.block_on(async {
        let files_clone = files.to_owned();
        let handlers = files_clone
            .into_iter()
            .map(|file: PathBuf| {
                let conn_clone = db_conn.clone();
                spawn(async move {
                    if let Err(e) = index_file(&file, &conn_clone).await {
                        error!("failed to index markdown file `{}`: {}", file.display(), e);
                    }
                })
            })
            .collect::<Vec<_>>();
        block_on(join_all(handlers));
    });
 }
 pub fn expand_path(path: String) -> String {
    if path.starts_with('~') {
        home_dir()
            .map(|dir| {
                dir.join(path.strip_prefix("~/").unwrap())
                    .into_os_string()
                    .into_string()
                    .unwrap()
            })
            .unwrap_or_else(|| {
                warn!(
                    "failed to parse env var `{}`, using default value `{}`",
                    var_name::WORK_DIR,
                    default_value::WORK_DIR
                );
                default_value::WORK_DIR.to_string()
            })
    } else {
        path
    }
 }
 pub fn parse_date(date_str: &str) -> ParseResult<DateTime<FixedOffset>> {
    DateTime::parse_from_str(format!("{}T120000", date_str).as_str(), DEFAULT_DATE_FORMAT)
 }
 pub fn get_md_file_basename(f_name: &str) -> String {
    f_name.replace(".md", "")
 }
@@ -0,0 +1,14 @@
 use crate::scheduler::tasks::basic::BasicTask;
 use crate::scheduler::tasks::Task;
 use sqlx::{Pool, Postgres};
 pub mod check_update;
 pub fn get_tasks(db_connection: Pool<Postgres>) -> Vec<Box<dyn Task>> {
    let db_conn_clone = db_connection.clone();
    vec![
        BasicTask::new(move || check_update::task(&db_conn_clone), "0/15 * * * * *")
            .unwrap()
            .to_task(),
    ]
 }
@@ -0,0 +1,17 @@
 mod api;
 pub mod cron;
 use crate::blog::api::{
    get_page_count::get_page_count, get_post::get_post, get_post_list::get_post_list,
 };
 use axum::routing::get;
 use axum::Router;
 use sqlx::{Pool, Postgres};
 pub fn get_router() -> Router<Pool<Postgres>> {
    Router::new()
        .route("/get_post_list", get(get_post_list))
        .route("/get_page_count", get(get_page_count))
        .route("/get_post/:post_id", get(get_post))
 }
@@ -0,0 +1,12 @@
 use crate::blog;
 use crate::scheduler::Scheduler;
 use sqlx::{Pool, Postgres};
 pub fn start(db_pool: Pool<Postgres>) {
    let scheduler = Scheduler::new();
    let _ = vec![blog::cron::get_tasks(db_pool.clone())]
        .into_iter()
        .map(|list| scheduler.insert_list(list))
        .collect::<Vec<_>>();
    scheduler.start().unwrap()
 }
@@ -0,0 +1,41 @@
 use std::env;
 use std::error::Error;
 use std::str::FromStr;
 use constants::config::database::{default_value, var_name};
 use sqlx::postgres::{PgConnectOptions, PgPoolOptions};
 use sqlx::{ConnectOptions, Pool, Postgres};
 use tracing::info;
 pub async fn init() -> Result<Pool<Postgres>, Box<dyn Error>> {
    let db_connect_option = PgConnectOptions::from_str(&parse_db_uri())
        .unwrap()
        .disable_statement_logging();
    Ok(PgPoolOptions::new()
        .max_connections(1) // todo: temporal solution, to be fixed
        .connect_with(db_connect_option)
        .await?)
 }
 fn parse_db_uri() -> String {
    env::var(var_name::URI).unwrap_or_else(|_| {
        info!(
            "`{}` env var is not set, \
            using `{}`, `{}`, `{}`, `{}` and `{}`",
            var_name::URI,
            var_name::USERNAME,
            var_name::PASSWORD,
            var_name::HOST,
            var_name::PORT,
            var_name::DBNAME
        );
        let postgres_user = env::var(var_name::USERNAME).unwrap_or(default_value::USERNAME.into());
        let postgres_password =
            env::var(var_name::PASSWORD).unwrap_or(default_value::PASSWORD.into());
        let db_host = env::var(var_name::HOST).unwrap_or(default_value::HOST.into());
        let db_port = env::var(var_name::PORT).unwrap_or(default_value::PORT.into());
        let postgres_db = env::var(var_name::DBNAME).unwrap_or(default_value::DBNAME.into());
        let db_type = default_value::DATABASE_TYPE;
        format!("{db_type}://{postgres_user}:{postgres_password}@{db_host}:{db_port}/{postgres_db}")
    })
 }
@@ -0,0 +1,106 @@
 use std::path::Path;
 use std::{env, io};
 use chrono::Local;
 use constants::config::general::{default_value, var_name};
 use dirs::home_dir;
 use tracing::info;
 use tracing_appender::{non_blocking, non_blocking::WorkerGuard, rolling};
 use tracing_subscriber::{
    filter::LevelFilter, fmt, fmt::format::Writer, fmt::time::FormatTime, fmt::MakeWriter,
    layer::SubscriberExt, Layer, Registry,
 };
 struct LocalTimer;
 impl FormatTime for LocalTimer {
    fn format_time(&self, w: &mut Writer<'_>) -> std::fmt::Result {
        write!(
            w,
            "{}",
            Local::now().format(constants::time::DEFAULT_TIME_FORMAT)
        )
    }
 }
 type _LogWriter = dyn for<'writer> MakeWriter<'writer, Writer = dyn io::Write + 'static> + 'static;
 pub fn init() -> (WorkerGuard, WorkerGuard) {
    let log_path = match env::var(var_name::LOG_DIR) {
        Ok(path) => Path::new(&path).to_path_buf(),
        Err(_) => {
            let path = if let Ok(default_log_path) = env::var(var_name::WORK_DIR) {
                expand_home_path(default_log_path)
            } else {
                let fallback_path = expand_home_path(default_value::WORK_DIR.to_string());
                println!(
                    "[warn] unset env var `{}` and `{}`, trying to log on fallback path: {}/log",
                    var_name::LOG_DIR,
                    var_name::WORK_DIR,
                    fallback_path
                );
                fallback_path
            };
            Path::new(&path).join("log")
        }
    };
    let (info_log_writer, info_guard) = non_blocking(rolling::never(&log_path, "info.log"));
    let (err_log_writer, error_guard) = non_blocking(rolling::never(&log_path, "error.log"));
    let info_format = tracing_subscriber::fmt::format()
        .with_level(true)
        .with_target(true)
        .with_source_location(true)
        .with_ansi(false);
    let err_format = tracing_subscriber::fmt::format()
        .with_level(true)
        .with_target(true)
        .with_source_location(true)
        .with_ansi(false);
    let stdout_format = tracing_subscriber::fmt::format()
        .with_level(true)
        .with_target(true)
        .with_source_location(true)
        .with_timer(LocalTimer);
    let subscribers = Registry::default()
        .with(
            fmt::Layer::default()
                .with_writer(info_log_writer)
                .event_format(info_format),
        )
        .with(
            fmt::Layer::default()
                .with_writer(err_log_writer)
                .event_format(err_format)
                .with_filter(LevelFilter::ERROR),
        )
        .with(
            fmt::Layer::default()
                .with_writer(io::stdout)
                .with_ansi(true)
                .event_format(stdout_format),
        );
    tracing::subscriber::set_global_default(subscribers)
        .expect("[fatal] failed to setup logging system");
    info!("logging to dir: {}", log_path.to_str().unwrap());
    (info_guard, error_guard)
 }
 fn expand_home_path(path: String) -> String {
    if path.starts_with('~') {
        let home_path = home_dir()
            .unwrap_or_else(|| panic!("[fatal] unable to locate home dir when parsing env `{}`, try to use absolute path instead", var_name::WORK_DIR));
        home_path
            .join(path.strip_prefix("~/").unwrap())
            .into_os_string()
            .into_string()
            .unwrap()
    } else {
        path
    }
 }
@@ -0,0 +1,14 @@
 use git2::opts::{set_server_connect_timeout_in_milliseconds, set_server_timeout_in_milliseconds};
 use tracing::warn;
 pub fn init() {
    // git2 option
    unsafe {
        if let Err(e) = set_server_connect_timeout_in_milliseconds(10_000) {
            warn!("failed to set git2 server connect timeout: {}", e);
        }
        if let Err(e) = set_server_timeout_in_milliseconds(60_000) {
            warn!("failed to set git2 server timeout: {}", e);
        }
    }
 }
@@ -0,0 +1,58 @@
 mod cron;
 mod database;
 pub mod logger;
 mod misc;
 mod schema;
 pub mod server;
 use macros::panic_with_log;
 use std::{env, panic};
 use tracing::{info, Level};
 pub fn load_env() {
    if let Some(env_file) = env::args().nth(1) {
        match dotenv::from_filename(&env_file) {
            Ok(_) => {
                println!("[info] env loaded from {}, starting up", env_file);
            }
            Err(e) => {
                panic!("[fatal] failed to read {}: {}", env_file, e);
            }
        }
    } else {
        println!("[info] no .env file referred, starting up")
    }
 }
 pub async fn start() {
    misc::init();
    // connect database
    let db_pool = match database::init().await {
        Ok(pool) => {
            info!("database connection pool initialized");
            pool
        }
        Err(e) => {
            panic_with_log!(
                Level::ERROR,
                "database connection pool failed to initialize: {}",
                e
            );
        }
    };
    // schema init
    schema::init(&db_pool).await;
    // load cron task
    cron::start(db_pool.clone());
    // api serve
    match server::start(db_pool).await {
        Ok(_) => {}
        Err(e) => {
            panic_with_log!(Level::ERROR, "server panicked: {}", e)
        }
    }
 }
@@ -0,0 +1,49 @@
 use sqlx::{query, Pool, Postgres};
 use tracing::info;
 const POST_BASE_MODEL: &str = r##"
 CREATE TABLE IF NOT EXISTS Post
 (
    post_id      UUID PRIMARY KEY,
    title        VARCHAR(255) NOT NULL,
    category     VARCHAR(255) NOT NULL,
    filename     TEXT UNIQUE  NOT NULL,
    summary      TEXT,
    sub_title    TEXT,
    content      TEXT         NOT NULL,
    last_update  TIMESTAMPTZ,
    first_update TIMESTAMPTZ  NOT NULL
 );
 "##;
 // base model, will add more cols at runtime
 const POST_META_MODEL: &str = r##"
 CREATE TABLE IF NOT EXISTS Meta
 (
    post_id      UUID PRIMARY KEY
 );
 "##;
 const POST_HASH_MODEL: &str = r##"
 CREATE TABLE IF NOT EXISTS Hash
 (
    post_id      UUID PRIMARY KEY,
    hash         VARCHAR(44)
 );
 "##;
 const TAG_MODEL: &str = r##"
 CREATE TABLE IF NOT EXISTS Tag
 (
    post_id UUID         NOT NULL,
    tag     VARCHAR(255) NOT NULL
 );
 "##;
 pub async fn init(db_connection: &Pool<Postgres>) {
    query(POST_BASE_MODEL).execute(db_connection).await.unwrap();
    query(POST_META_MODEL).execute(db_connection).await.unwrap();
    query(TAG_MODEL).execute(db_connection).await.unwrap();
    query(POST_HASH_MODEL).execute(db_connection).await.unwrap();
    info!("database schema initialized");
 }
@@ -0,0 +1,52 @@
 use std::env;
 use std::error::Error;
 use std::num::ParseIntError;
 use std::process::exit;
 use crate::blog;
 use axum::Router;
 use constants::config::server::{default_value, var_name};
 use macros::panic_with_log;
 use sqlx::{Pool, Postgres};
 use tracing::{error, info, warn, Level};
 pub async fn start(db_pool: Pool<Postgres>) -> Result<(), Box<dyn Error>> {
    let app = Router::new()
        .nest("/blog", blog::get_router())
        .with_state(db_pool);
    let port: u32 = match env::var(var_name::PORT) {
        Ok(value) => value.parse().unwrap_or_else(|e: ParseIntError| {
            warn!(
                "failed to parse `{}`, using default port: {}",
                var_name::PORT,
                e.to_string()
            );
            default_value::PORT
        }),
        Err(_) => default_value::PORT,
    };
    let listener =
        match tokio::net::TcpListener::bind(format!("{}:{}", default_value::HOST, port)).await {
            Ok(listener) => {
                info!("server started on {}:{}", default_value::HOST, port);
                listener
            }
            Err(e) => {
                panic_with_log!(
                    Level::ERROR,
                    "failed to start server on {}:{}: {}",
                    default_value::HOST,
                    port,
                    e.to_string()
                );
            }
        };
    axum::serve(listener, app).await.unwrap_or_else(|e| {
        error!("failed to start axum: {}", e.to_string());
        exit(1);
    });
    Ok(())
 }
@@ -0,0 +1,13 @@
 mod blog;
 mod init;
 mod scheduler;
 mod utils;
 #[tokio::main]
 async fn main() {
    init::load_env();
    let _guards = init::logger::init();
    init::start().await;
 }
@@ -0,0 +1,194 @@
 use crate::{
    scheduler::scheduler_error::SchedulerError,
    scheduler::scheduler_error::SchedulerError::IdAlreadyRunning,
    scheduler::scheduler_error::SchedulerError::IdNotFound, scheduler::sleeper::SkippableSleeper,
    scheduler::tasks::Task,
 };
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::RwLock;
 use std::{collections::HashMap, sync::Arc, thread};
 use tracing::log::error;
 use uuid::Uuid;
 pub mod scheduler_error;
 mod sleeper;
 mod task_func;
 pub mod tasks;
 struct TaskStatus {
    sleeper: Option<Arc<SkippableSleeper>>,
    is_alive: AtomicBool,
 }
 #[derive(Default)]
 pub struct Scheduler {
    tasks: Arc<RwLock<HashMap<Uuid, Arc<Box<dyn Task>>>>>,
    running: Arc<RwLock<HashMap<Uuid, Arc<TaskStatus>>>>,
 }
 impl Scheduler {
    /// Start all tasks in the scheduler
    pub fn start(&self) -> Result<(), SchedulerError> {
        for (k, _v) in self.tasks.read()?.iter() {
            self.run_non_blocking(k)?
        }
        Ok(())
    }
    /// Terminate all tasks in the scheduler
    pub fn halt() {}
    fn run_task(
        running: Arc<RwLock<HashMap<Uuid, Arc<TaskStatus>>>>,
        id: Uuid,
        task: Arc<Box<dyn Task>>,
    ) -> Result<(), SchedulerError> {
        if running.read()?.get(&id).is_some() {
            return Err(IdAlreadyRunning);
        } else {
            running.write()?.insert(
                id,
                TaskStatus {
                    sleeper: None,
                    is_alive: AtomicBool::new(true),
                }
                .into(),
            );
        }
        loop {
            if let Some(next_execution) = task.get_next_execution() {
                // guarantee is alive
                let task_status = {
                    let running_reading_guard = running.read()?;
                    running_reading_guard.get(&id).cloned().clone()
                };
                if let Some(task_status) = task_status {
                    if !&task_status.is_alive.load(Ordering::SeqCst) {
                        {
                            let mut running_lock_guard = running.write()?;
                            running_lock_guard.remove(&id);
                        }
                        return Ok(());
                    } else {
                        let sleeper = Arc::from(SkippableSleeper::from(next_execution));
                        {
                            let mut running_lock_guard = running.write()?;
                            running_lock_guard.insert(
                                id,
                                TaskStatus {
                                    sleeper: Some(sleeper.clone()),
                                    is_alive: AtomicBool::new(true),
                                }
                                .into(),
                            );
                        }
                        sleeper.start();
                        task.call();
                    }
                }
            } else {
                error!("unexpected error ");
                break;
            }
        }
        Ok(())
    }
    /// Run a task with `id`
    pub fn run(&self, id: &Uuid) -> Result<(), SchedulerError> {
        let id = id.to_owned();
        if let Some(task) = self.tasks.read()?.get(&id) {
            Self::run_task(self.running.clone(), id, task.clone())
        } else {
            Err(IdNotFound)
        }
    }
    pub fn run_non_blocking(&self, id: &Uuid) -> Result<(), SchedulerError> {
        let id = id.to_owned();
        if let Some(task) = self.tasks.read()?.get(&id) {
            let running_clone = self.running.clone();
            let task_clone = task.clone();
            thread::spawn(move || Self::run_task(running_clone, id, task_clone));
            Ok(())
        } else {
            Err(IdNotFound)
        }
    }
    fn get_running(&self, id: &Uuid) -> Option<Arc<TaskStatus>> {
        let ret = self.running.read().unwrap().get(id).cloned();
        ret
    }
    /// Stop a task with `id`
    pub fn stop(&self, id: &Uuid) -> Result<(), SchedulerError> {
        match self.get_running(id) {
            None => Err(IdNotFound),
            Some(status) => {
                status.is_alive.store(false, Ordering::SeqCst);
                if let Some(s) = &status.sleeper {
                    s.skip();
                } else {
                    return Err(IdAlreadyRunning);
                }
                Ok(())
            }
        }
    }
    pub fn now(&self, id: &Uuid) -> Result<(), SchedulerError> {
        match self.get_running(id) {
            None => Err(IdNotFound),
            Some(status) => {
                if let Some(s) = &status.sleeper {
                    s.skip()
                } else {
                    return Err(IdAlreadyRunning);
                }
                Ok(())
            }
        }
    }
    pub fn insert(&self, task: Box<dyn Task>) -> Result<Uuid, SchedulerError> {
        let id = Uuid::new_v4();
        self.tasks.write()?.insert(id, Arc::new(task));
        Ok(id)
    }
    pub fn insert_list(&self, tasks: Vec<Box<dyn Task>>) -> Result<Vec<Uuid>, SchedulerError> {
        tasks.into_iter().map(|t| self.insert(t)).collect()
    }
    pub fn new() -> Self {
        Self::default()
    }
 }
 #[cfg(test)]
 mod tests {
    use crate::scheduler::tasks::basic::BasicTask;
    use crate::scheduler::Scheduler;
    use std::error::Error;
    use std::thread;
    use std::time::Duration;
    #[test]
    fn test_run() -> Result<(), Box<dyn Error>> {
        let scheduler = Scheduler::default();
        let task = BasicTask::new(|| println!("test print"), "* * * * * *")?;
        let id = scheduler.insert(Box::new(task))?;
        for i in 1..=2 {
            println!("Loop {} start", i);
            println!("Run {}", i);
            scheduler.run_non_blocking(&id)?;
            thread::sleep(Duration::from_secs(4));
            scheduler.stop(&id)?;
            println!("Stop {}", i);
            thread::sleep(Duration::from_secs(2));
            println!("Loop {} finished", i);
        }
        Ok(())
    }
 }
@@ -0,0 +1,44 @@
 use crate::scheduler::scheduler_error::SchedulerError::MutexPoison;
 use std::error::Error;
 use std::fmt::{Debug, Display, Formatter};
 use std::sync::PoisonError;
 pub enum SchedulerError {
    IdNotFound,
    IdAlreadyRunning,
    MutexPoison(String),
 }
 impl<T> From<PoisonError<T>> for SchedulerError {
    fn from(value: PoisonError<T>) -> Self {
        MutexPoison(value.to_string())
    }
 }
 impl Debug for SchedulerError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self)
    }
 }
 impl Display for SchedulerError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}",
            match self {
                SchedulerError::IdNotFound => {
                    "SchedulerError::IdNotFound".to_string()
                }
                SchedulerError::IdAlreadyRunning => {
                    "SchedulerError::IdAlreadyRunning".to_string()
                }
                MutexPoison(str) => {
                    format!("SchedulerError::MutexPoison: {}", str)
                }
            }
        )
    }
 }
 impl Error for SchedulerError {}
@@ -0,0 +1,77 @@
 use chrono::{DateTime, Utc};
 use std::sync::{Arc, Condvar, Mutex};
 use std::thread;
 use std::time::Duration;
 #[derive(Clone, Debug, Default)]
 pub struct SkippableSleeper {
    pub duration: Duration,
    state: Arc<(Mutex<bool>, Condvar)>,
 }
 impl SkippableSleeper {
    pub fn new(duration: Duration) -> Self {
        SkippableSleeper {
            duration,
            state: Arc::new((Mutex::new(false), Condvar::new())),
        }
    }
    // Blocks until the duration has passed or skip() is called
    pub fn start(&self) {
        let (lock, cvar) = &*self.state;
        let mut received = lock.lock().unwrap();
        let state_clone = Arc::clone(&self.state);
        let duration_clone = self.duration;
        thread::spawn(move || {
            thread::sleep(duration_clone);
            let (lock, cvar) = &*state_clone;
            let mut received = lock.lock().unwrap();
            *received = true;
            cvar.notify_one();
        });
        while !*received {
            received = cvar.wait(received).unwrap();
        }
    }
    // Skip the blocking delay
    pub fn skip(&self) {
        let (lock, cvar) = &*self.state;
        let mut received = lock.lock().unwrap();
        *received = true;
        cvar.notify_one();
    }
 }
 impl From<DateTime<Utc>> for SkippableSleeper {
    fn from(value: DateTime<Utc>) -> Self {
        let from_utc_timestamp = value.timestamp() as u64;
        let curr_utc_timestamp = Utc::now().timestamp() as u64;
        SkippableSleeper::new(Duration::from_secs(from_utc_timestamp - curr_utc_timestamp))
    }
 }
 #[cfg(test)]
 mod test {
    use crate::scheduler::sleeper::SkippableSleeper;
    use std::thread;
    use std::time::Duration;
    #[test]
    fn usage() {
        let sleeper = SkippableSleeper::new(Duration::new(10, 0));
        thread::spawn({
            let sleeper = sleeper.clone();
            move || {
                println!("Sleeping...");
                sleeper.start();
                println!("Woke up!");
            }
        });
        println!("Start Sleeping...");
        thread::sleep(Duration::from_secs(4));
        println!("Skipping sleep...");
        sleeper.skip();
    }
 }
@@ -0,0 +1,3 @@
 pub trait TaskFunc: Fn() + Send + Sync + 'static {}
 impl<T> TaskFunc for T where T: Fn() + Send + Sync + Clone + 'static {}
@@ -0,0 +1,37 @@
 use crate::scheduler::task_func::TaskFunc;
 use crate::scheduler::tasks::Task;
 use chrono::{DateTime, Utc};
 use cron::Schedule;
 use std::error::Error;
 use std::str::FromStr;
 pub struct BasicTask {
    schedule: Schedule,
    func: Box<dyn TaskFunc>,
 }
 impl BasicTask {
    pub fn new<F>(func: F, cron_expr: &str) -> Result<Self, Box<dyn Error>>
    where
        F: TaskFunc,
    {
        Ok(BasicTask {
            schedule: Schedule::from_str(cron_expr)?,
            func: Box::new(func),
        })
    }
    pub fn to_task(self) -> Box<dyn Task> {
        Box::new(self)
    }
 }
 impl Task for BasicTask {
    fn get_next_execution(&self) -> Option<DateTime<Utc>> {
        self.schedule.upcoming(Utc).next()
    }
    fn call(&self) {
        (self.func)()
    }
 }
@@ -0,0 +1,8 @@
 use chrono::{DateTime, Utc};
 pub mod basic;
 pub trait Task: Send + Sync {
    fn get_next_execution(&self) -> Option<DateTime<Utc>>;
    fn call(&self);
 }
@@ -0,0 +1,195 @@
 /// git merge
 /// based on https://github.com/rust-lang/git2-rs/blob/master/examples/pull.rs
 /// https://github.com/rust-lang/git2-rs/commit/f3b87baed1e33d6c2d94fe1fa6aa6503a071d837
 ///
 use git2::{
    build, AnnotatedCommit, AutotagOption, Delta, FetchOptions, Reference, Remote, Repository,
 };
 use std::path::PathBuf;
 use tracing::{error, warn};
 #[derive(Debug, Eq, PartialEq)]
 pub struct FileDelta {
    pub old_path: Option<PathBuf>,
    pub new_path: Option<PathBuf>,
    pub status: Delta,
 }
 fn do_fetch<'a>(
    repo: &'a Repository,
    refs: &[&str],
    remote: &'a mut Remote,
 ) -> Result<AnnotatedCommit<'a>, git2::Error> {
    let mut fetch_option = FetchOptions::new();
    // Always fetch all tags.
    // Perform a download and also update tips
    fetch_option.download_tags(AutotagOption::All);
    remote.fetch(refs, Some(&mut fetch_option), None)?;
    let fetch_head = repo.find_reference("FETCH_HEAD")?;
    repo.reference_to_annotated_commit(&fetch_head)
 }
 fn fast_forward(
    repo: &Repository,
    lb: &mut Reference,
    rc: &AnnotatedCommit,
 ) -> Result<(), git2::Error> {
    let name = match lb.name() {
        Some(s) => s.to_string(),
        None => String::from_utf8_lossy(lb.name_bytes()).to_string(),
    };
    let msg = format!("fast-forward({}) -> {}", name, rc.id());
    // println!("{}", msg);
    lb.set_target(rc.id(), &msg)?;
    repo.set_head(&name)?;
    repo.checkout_head(Some(
        build::CheckoutBuilder::default()
            // For some reason, the force is required to make the working directory actually get updated
            // I suspect we should be adding some logic to handle dirty working directory states,
            // but this is just an example so maybe not.
            .force(),
    ))?;
    Ok(())
 }
 fn normal_merge(
    repo: &Repository,
    local: &AnnotatedCommit,
    remote: &AnnotatedCommit,
 ) -> Result<(), git2::Error> {
    let local_tree = repo.find_commit(local.id())?.tree()?;
    let remote_tree = repo.find_commit(remote.id())?.tree()?;
    let ancestor = repo
        .find_commit(repo.merge_base(local.id(), remote.id())?)?
        .tree()?;
    let mut idx = repo.merge_trees(&ancestor, &local_tree, &remote_tree, None)?;
    if idx.has_conflicts() {
        warn!("merge conflicts detected");
        repo.checkout_index(Some(&mut idx), None)?;
        return Ok(());
    }
    let result_tree = repo.find_tree(idx.write_tree_to(repo)?)?;
    // now create the merge commit
    let msg = format!("merge({}) -> {}", remote.id(), local.id());
    let sig = repo.signature()?;
    let local_commit = repo.find_commit(local.id())?;
    let remote_commit = repo.find_commit(remote.id())?;
    // Do our merge commit and set the current branch head to that commit.
    let _merge_commit = repo.commit(
        Some("HEAD"),
        &sig,
        &sig,
        &msg,
        &result_tree,
        &[&local_commit, &remote_commit],
    )?;
    // Set working tree to match head.
    repo.checkout_head(None)?;
    Ok(())
 }
 fn do_merge<'a>(
    repo: &'a Repository,
    remote_branch: &str,
    fetch_commit: AnnotatedCommit<'a>,
 ) -> Result<Vec<FileDelta>, git2::Error> {
    // 1. do a merge analysis
    let analysis = repo.merge_analysis(&[&fetch_commit])?;
    let head_commit = repo.reference_to_annotated_commit(&repo.head()?)?;
    // 2. Do the appropriate merge
    if analysis.0.is_fast_forward() {
        // println!("Doing a fast-forward");
        // do a fast-forward
        let ref_name = format!("refs/heads/{}", remote_branch);
        match repo.find_reference(&ref_name) {
            Ok(mut r) => {
                fast_forward(repo, &mut r, &fetch_commit)?;
            }
            Err(_) => {
                // The branch doesn't exist, so set the reference to the
                // commit directly. Usually this is because you are pulling
                // into an empty repository.
                repo.reference(
                    &ref_name,
                    fetch_commit.id(),
                    true,
                    &format!("({}) -> {}", remote_branch, fetch_commit.id()),
                )?;
                repo.set_head(&ref_name)?;
                repo.checkout_head(Some(
                    build::CheckoutBuilder::default()
                        .allow_conflicts(true)
                        .conflict_style_merge(true)
                        .force(),
                ))?;
            }
        };
    } else if analysis.0.is_normal() {
        // do a normal merge
        normal_merge(repo, &head_commit, &fetch_commit)?;
    }
    // else {
    //     // already up-to-date
    //     println!("Nothing to do...");
    // }
    calculate_diff(repo, &head_commit, &fetch_commit)
 }
 fn calculate_diff(
    repo: &Repository,
    local: &AnnotatedCommit,
    remote: &AnnotatedCommit,
 ) -> Result<Vec<FileDelta>, git2::Error> {
    let local_tree = repo.find_commit(local.id())?.tree()?;
    let remote_tree = repo.find_commit(remote.id())?.tree()?;
    let diff = repo.diff_tree_to_tree(Some(&local_tree), Some(&remote_tree), None)?;
    let mut updated_files: Vec<FileDelta> = Vec::new();
    if let Err(e) = diff.foreach(
        &mut |d, _| {
            // let delta = d.status();
            //
            // let n_path = d.new_file().path();
            // let o_path = d.old_file().path();
            //
            // if let Some(path) = n_path {
            //     updated_files.insert(path.to_owned());
            // }
            // if let Some(path) = o_path {
            //     updated_files.insert(path.to_owned());
            // }
            updated_files.push(FileDelta {
                old_path: d.old_file().path().map(PathBuf::from),
                new_path: d.new_file().path().map(PathBuf::from),
                status: d.status(),
            });
            true // Continue
        },
        None,
        None,
        None,
    ) {
        error!("error at calculating diff: {:?}", e);
    }
    Ok(updated_files.into_iter().collect())
 }
 pub fn sync(
    remote_name: &str,
    remote_branch: &str,
    repo: &Repository,
 ) -> Result<Vec<FileDelta>, git2::Error> {
    let mut remote = repo.find_remote(remote_name)?;
    let fetch_commit = do_fetch(repo, &[remote_branch], &mut remote)?;
    do_merge(repo, remote_branch, fetch_commit)
 }
@@ -0,0 +1 @@
 pub mod git;
@@ -0,0 +1,6 @@
 [package]
 name = "constants"
 version = "0.1.0"
 edition = "2021"
 [dependencies]
@@ -0,0 +1 @@
 pub const PAGE_SIZE: u32 = 6;
@@ -0,0 +1,48 @@
 // Database related
 pub mod database {
    pub mod var_name {
        pub const URI: &str = "DATABASE_URL";
        pub const USERNAME: &str = "POSTGRES_USER";
        pub const PASSWORD: &str = "POSTGRES_PASSWORD";
        pub const HOST: &str = "POSTGRES_HOST";
        pub const PORT: &str = "POSTGRES_PORT";
        pub const DBNAME: &str = "POSTGRES_DB";
    }
    pub mod default_value {
        pub const USERNAME: &str = "";
        pub const PASSWORD: &str = "";
        pub const HOST: &str = "localhost";
        pub const PORT: &str = "5432";
        pub const DBNAME: &str = "nocturne";
        pub const DATABASE_TYPE: &str = "postgresql";
    }
 }
 pub mod server {
    pub mod var_name {
        pub const PORT: &str = "BACKEND_PORT";
        pub const HOST: &str = "BACKEND_HOST";
    }
    pub mod default_value {
        pub const PORT: u32 = 3001;
        pub const HOST: &str = "0.0.0.0";
    }
 }
 pub mod general {
    pub mod var_name {
        pub const LOG_DIR: &str = "LOG_DIR";
        pub const WORK_DIR: &str = "WORK_DIR";
        pub const BLOG_GIT_URL: &str = "BLOG_GIT_URL";
        pub const BLOG_GIT_REMOTE_BRANCH: &str = "BLOG_GIT_REMOTE_BRANCH";
        pub const BLOG_GIT_REMOTE_NAME: &str = "BLOG_GIT_REMOTE_NAME";
    }
    pub mod default_value {
        pub const WORK_DIR: &str = "~/.nocturne";
        pub const BLOG_GIT_REMOTE_BRANCH: &str = "master";
        pub const BLOG_GIT_REMOTE_NAME: &str = "origin";
    }
 }
@@ -0,0 +1,3 @@
 pub mod blog;
 pub mod config;
 pub mod time;
@@ -0,0 +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";
@@ -0,0 +1,8 @@
 [package]
 name = "macros"
 version = "0.1.0"
 edition = "2021"
 [dependencies]
 tracing = "0.1.40"
 tracing-subscriber = "0.3.18"
@@ -0,0 +1 @@
 mod log;
@@ -0,0 +1,45 @@
 /// log the message at specific log level and exit(1)
 ///
 /// # Example
 /// ```rust
 ///
 /// use macros::panic_with_log;
 /// use tracing::Level;
 ///
 /// panic_with_log!(Level::ERROR, "Test panicked: {}", 42);
 /// ```
 #[macro_export]
 macro_rules! panic_with_log {
    ($level:expr, $msg:literal $(, $($arg:tt)*)?) => {{
        use std::process;
        use tracing::event;
        event!($level, $msg $(, $($arg)*)?);
        process::exit(1);
    }};
 }
 #[cfg(test)]
 mod tests {
    #[test]
    fn test_panic_with_log() {
        use std::io;
        use tracing::Level;
        use tracing_subscriber::prelude::*;
        use tracing_subscriber::{fmt, Registry};
        let format = tracing_subscriber::fmt::format()
            .with_level(true)
            .with_target(true)
            .with_source_location(true);
        let subscriber = Registry::default().with(
            fmt::Layer::default()
                .with_writer(io::stderr)
                .event_format(format),
        );
        tracing::subscriber::set_global_default(subscriber).unwrap();
        panic_with_log!(Level::ERROR, "Test panicked: {}", 42);
    }
 }
@@ -0,0 +1,14 @@
 [package]
 name = "markdown"
 version = "0.1.0"
 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.9.0"
 sha2 = "0.10.8"
 base64 = "0.22.1"
 thiserror = "2.0.3"
@@ -0,0 +1,16 @@
 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 },
    #[error("fs error: {}", msg)]
    FSError { msg: String },
 }
@@ -0,0 +1,68 @@
 mod error;
 mod utils;
 use std::fs;
 use std::path::Path;
 use std::str::FromStr;
 use crate::error::Error;
 use crate::utils::front_matter::{parse_front_matter, split_md_front_matter};
 use base64::{engine::general_purpose, Engine};
 use serde::Serialize;
 use serde_json::Value;
 use sha2::{Digest, Sha256};
 use uuid::Uuid;
 #[derive(Default, Debug, Serialize)]
 pub struct MdFile {
    pub file_id: Uuid,
    pub filename: String,
    pub meta: Value,
    pub content: String,
    pub hash: String,
 }
 impl MdFile {
    pub fn from_file(file_path: &Path) -> Result<MdFile, Error> {
        let raw_file = match fs::read_to_string(file_path) {
            Ok(file) => file,
            Err(e) => return Err(Error::FSError { msg: e.to_string() }),
        };
        let raw_file_bytes = raw_file.as_bytes().to_vec();
        let (front_matter_str, content) = split_md_front_matter(raw_file);
        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(&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,
        })
    }
 }
 fn calculate_hash_base64(bytes: &Vec<u8>) -> String {
    let mut hasher = Sha256::new();
    hasher.update(bytes);
    let hash = hasher.finalize().to_vec();
    general_purpose::STANDARD.encode(hash)
 }
@@ -0,0 +1,81 @@
 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: String) -> (String, String) {
    let re = Regex::new(r"(?s)^(---\n.*?\n---\n)(.*)").unwrap();
    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)
    }
 }
 pub fn parse_front_matter(front_matter: &str) -> Result<Value, Box<dyn Error>> {
    let parsed_f_matter = YamlLoader::load_from_str(front_matter)?;
    if parsed_f_matter.is_empty() {
        Ok(Value::String(String::new()))
    } else {
        Ok(yaml_to_serde(&parsed_f_matter[0]))
    }
 }
 #[cfg(test)]
 mod tests {
    use crate::utils::front_matter::{parse_front_matter, split_md_front_matter};
    #[test]
    fn front_matter_to_string() {
        let (front_matter, main_content) = split_md_front_matter(
            r##"---
 title: test_title
 date: 0000-00-00+0000
 category: test
 id: bf03afd8-61b4-4e78-a34a-8b3ee39adf16
 sub_title: sub_title
 summary: summary
 tags: [ "test1", "test2" ]
 ---
 test body
 "##
            .to_string(),
        );
        assert_eq!(
            front_matter,
            r##"---
 title: test_title
 date: 0000-00-00+0000
 category: test
 id: bf03afd8-61b4-4e78-a34a-8b3ee39adf16
 sub_title: sub_title
 summary: summary
 tags: [ "test1", "test2" ]
 ---
 "##
        );
        assert_eq!(main_content, "\ntest body\n\n");
    }
    #[test]
    fn test_front_matter_parser() {
        dbg!(parse_front_matter(
            r##"---
 title: test_title
 date: 0000-00-00+0000
 category: test
 id: bf03afd8-61b4-4e78-a34a-8b3ee39adf16
 sub_title: sub_title
 summary: summary
 tags: [ "test1", "test2" ]
 ---
 "##,
        ))
        .expect("Failed to parse front matter");
    }
 }
@@ -0,0 +1,2 @@
 pub mod front_matter;
 mod yaml;
@@ -0,0 +1,29 @@
 use serde_json::Value;
 use std::str::FromStr;
 use yaml_rust2::Yaml;
 pub fn yaml_to_serde(yaml: &Yaml) -> Value {
    match yaml {
        Yaml::Null => Value::Null,
        Yaml::Boolean(b) => Value::Bool(*b),
        Yaml::Integer(i) => Value::Number(serde_json::Number::from(*i)),
        Yaml::Real(s) => Value::Number(serde_json::Number::from_str(s).unwrap()),
        Yaml::String(s) => Value::String(s.clone()),
        Yaml::Array(arr) => Value::Array(arr.iter().map(yaml_to_serde).collect()),
        Yaml::Hash(hash) => {
            let obj: serde_json::map::Map<String, Value> = hash
                .iter()
                .map(|(k, v)| {
                    let key = match k {
                        Yaml::String(s) => s.clone(),
                        _ => "INVALID_KEY".to_string(),
                    };
                    (key, yaml_to_serde(v))
                })
                .collect();
            Value::Object(obj)
        }
        Yaml::Alias(_) => Value::Null,
        Yaml::BadValue => Value::Null,
    }
 }
@@ -1,116 +0,0 @@
 'use client';
 import React, { useEffect, useState } from 'react';
 import {
    Image,
    Navbar as NextUINavbar,
    NavbarBrand,
    NavbarContent,
    NavbarItem,
    NavbarMenu,
    NavbarMenuItem,
    NavbarMenuToggle
 } from '@nextui-org/react';
 import Link from 'next/link';
 import { usePathname } from 'next/navigation';
 import ThemeSwitcher from '@/components/ThemeSwitcher';
 const entries: { display_name: string; href: string; }[] = [
    {
        display_name: 'Home',
        href: '/'
    },
    {
        display_name: 'About',
        href: '/about'
    },
    {
        display_name: 'Blog',
        href: '/blog'
    }
 ];
 function Navbar() {
    const [ scrolled, setScrolled ] = useState(false);
    useEffect(() => {
        const handleScroll = () => {
            const isScrolled = window.scrollY > 0;
            setScrolled(isScrolled);
        };
        window.addEventListener('scroll', handleScroll);
        return () => {
            window.removeEventListener('scroll', handleScroll);
        };
    }, []);
    return (
        <>
            <NextUINavbar isBlurred isBordered>
                <NavbarContent className="sm:hidden" justify="start">
                    <NavbarMenuToggle />
                </NavbarContent>
                <NavbarContent className="sm:hidden pr-3" justify="center">
                    <Image
                        src={ 'https://avatars.githubusercontent.com/u/46409277?v=4' }
                        alt={ 'avatar' }
                        className={ 'rounded-full h-[3rem]' }
                    ></Image>
                    <NavbarBrand>
                        <p className="font-bold text-inherit">{ 'Lumither\'s site' }</p>
                    </NavbarBrand>
                </NavbarContent>
                <NavbarContent className="hidden sm:flex gap-4" justify="center">
                    <Image
                        src={ 'https://avatars.githubusercontent.com/u/46409277?v=4' }
                        alt={ 'avatar' }
                        className={ 'rounded-full h-[3rem]' }
                    ></Image>
                    <NavbarBrand>
                        <p className="font-bold text-inherit">{ 'Lumither\'s site' }</p>
                    </NavbarBrand>
                    { entries.map((item, index) => (
                        // eslint-disable-next-line react-hooks/rules-of-hooks
                        <NavbarItem key={ index } isActive={ usePathname() === item.href }>
                            <Link
                                className="w-full"
                                href={ item.href }
                            >
                                { item.display_name }
                            </Link>
                        </NavbarItem>
                    )) }
                </NavbarContent>
                <NavbarContent justify="end">
                    <NavbarItem>
                        <ThemeSwitcher />
                    </NavbarItem>
                </NavbarContent>
                <NavbarMenu>
                    { entries.map((item, index) => (
                        <NavbarMenuItem key={ index }>
                            <Link
                                className="w-full"
                                href={ item.href }
                            >
                                { item.display_name }
                            </Link>
                        </NavbarMenuItem>
                    )) }
                </NavbarMenu>
            </NextUINavbar>
        </>
    );
 }
 export default Navbar;
@@ -1,38 +0,0 @@
 'use client';
 import React, { useEffect, useState } from 'react';
 import { useTheme } from 'next-themes';
 import { Switch } from '@nextui-org/react';
 import { MdOutlineDarkMode, MdOutlineLightMode } from 'react-icons/md';
 function ThemeSwitcher() {
    const [ mounted, setMounted ] = useState(false);
    const { setTheme } = useTheme();
    useEffect(() => {
        setMounted(true);
    }, []);
    if (!mounted) {
        return null;
    }
    return (
        <div>
            <Switch
                color={ 'default' }
                startContent={ <MdOutlineLightMode /> }
                endContent={ <MdOutlineDarkMode /> }
                onValueChange={ (isSelected) => {
                    if (isSelected) {
                        setTheme('light');
                    } else {
                        setTheme('dark');
                    }
                } }
            ></Switch>
        </div>
    );
 }
 export default ThemeSwitcher;
@@ -0,0 +1,9 @@
 FROM rust:latest
 WORKDIR /app
 COPY . .
 RUN cargo build
 CMD cargo r
@@ -0,0 +1,13 @@
 # docker/dev.Dockerfile
 FROM node:latest
 WORKDIR /app
 COPY package.json ./
 RUN npm install
 ENV NEXT_TELEMETRY_DISABLED 1
 CMD npm run dev
@@ -0,0 +1,10 @@
 FROM rust:latest AS builder
 WORKDIR /app
 COPY . .
 RUN ["cargo", "build", "-r"]
 FROM gcr.io/distroless/cc AS production
 ARG ARCH
 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 ["./api_server"]
@@ -0,0 +1,15 @@
 FROM node:22 AS builder
 WORKDIR /app
 ENV NEXT_TELEMETRY_DISABLED=1
 COPY package*.json ./
 RUN npm install
 COPY . .
 RUN npm run build
 FROM gcr.io/distroless/nodejs22 AS production
 ENV NEXT_TELEMETRY_DISABLED=1
 COPY --from=builder /app/next.config.mjs ./
 COPY --from=builder /app/.next/standalone ./
 COPY --from=builder /app/.next/static ./.next/static
 ENV HOSTNAME="0.0.0.0"
 CMD ["./server.js"]
@@ -0,0 +1,36 @@
 services:
  frontend:
    build:
      context: ./frontend
      dockerfile: ../container/dev/frontend.containerfile
    restart: always
    ports:
      - "3000:3000"
    volumes:
      - ./frontend:/app
      - /app/node_modules
      - /app/.next
    env_file:
      - ./container/dev/.env
    dns:
      - 1.1.1.1
  backend:
    build:
      context: ./backend
      dockerfile: ../container/dev/backend.containerfile
    restart: always
    ports:
      - "3001:3001"
    volumes:
      - ./blog_posts_git:/app/blog_posts_git:ro
    env_file:
      - ./container/dev/.env
  postgres:
    image: postgres:16.3
    ports:
      - 5432:5432
    env_file:
      - ./container/dev/.env
@@ -0,0 +1,10 @@
 /node_modules
 /.next
 /out
 /build
 .DS_Store
 *.pem
 .env*.local
@@ -0,0 +1,43 @@
 # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 # dependencies
 /node_modules
 /.pnp
 .pnp.js
 .yarn/install-state.gz
 # testing
 /coverage
 # next.js
 /.next/
 /out/
 # production
 /build
 # misc
 .DS_Store
 *.pem
 # debug
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 # local env files
 .env*.local
 # vercel
 .vercel
 # typescript
 *.tsbuildinfo
 next-env.d.ts
 # bun
 bun.lockb
 # ide related
 .idea
 /package-lock.json
@@ -6,7 +6,7 @@ function Layout({
    children: React.ReactNode;
 }) {
    return (
-        <div className={ 'flex items-stretch justify-center' }>
+        <div className={ 'flex p-7' }>
            { children }
        </div>
    );
@@ -0,0 +1,15 @@
 import React from 'react';
 import MarkdownRenderer from '@/app/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;
@@ -0,0 +1,58 @@
 import { Card } from '@nextui-org/react';
 import React from 'react';
 import { CardBody } from '@nextui-org/card';
 import Link from 'next/link';
 const About = () => {
    return (
        <div className={ `flex flex-col w-full justify-center align-middle h-dvh` }>
            <div className={ 'md:relative md:h-[130px] mb-4 md:mb-0' }>
                <div className={ 'md:relative md:left-[20%] flex flex-col w-fit' }>
                    <p className={ 'text-pretty text-3xl' }>{ '讷，远道而来的' }<span
                        className={ 'break-keep underline decoration-sky-400 dark:decoration-sky-700 decoration-4 underline-offset-0' }>旅人</span>
                    </p>
                    <p className={ 'text-pretty md:text-2xl mt-1 md:ml-4' }>{ '愿意坐下来听个故事吗...' }</p>
                    <p className={ 'hidden md:block text-lg md:ml-8' }>{ '一个关于一位' }<span
                        className={ 'text-gray-700 dark:text-gray-400 text-sm transition-colors' }>{ '█' }</span>{ '追寻' }<span
                        className={ 'text-gray-700 dark:text-gray-400 text-sm transition-colors' }>{ '█' }</span>{ '，探索' }<span
                        className={ 'text-gray-700 dark:text-gray-400 text-sm transition-colors' }>{ '█' }</span>{ '的故事' }
                    </p>
                </div>
            </div>
            <div className={ `flex justify-center w-full h-[60%] md:h-[40%]` }>
                <div
                    className={ `flex flex-col md:flex-row w-full md:w-[85%] lg:w-[90%] xl:w-[85%] p-4 gap-x-7 gap-y-5` }>
                    <Card
                        isHoverable
                        className={ 'w-full h-[45%] md:h-full' }
                        as={ Link }
                        href={ '/about/me' }
                        isPressable
                    >
                        <CardBody>
                            <div className={ 'h-full flex flex-col justify-center' }>
                                <p className={ 'text-center text-3xl h-fit' }>关于我</p>
                            </div>
                        </CardBody>
                    </Card>
                    <Card
                        isHoverable
                        className={ 'w-full h-[45%] md:h-full' }
                        as={ Link }
                        href={ '/about/website' }
                        isPressable
                    >
                        <CardBody>
                            <div className={ 'h-full flex flex-col justify-center' }>
                                <p className={ 'text-center text-3xl h-fit' }>关于这个网站</p>
                            </div>
                        </CardBody>
                    </Card>
                </div>
            </div>
            <p className={ 'text-center' }>*目前还没想到如何设计这一页，先摸鱼会（笑）</p>
        </div>
    );
 };
 export default About;
@@ -0,0 +1,14 @@
 import React from 'react';
 import MarkdownRenderer from '@/app/public/MarkdownRenderer';
 import { fetchText } from '@/app/fetch';
 const Website = async () => {
    return (
        <div className={ 'p-5' }>
            <MarkdownRenderer>
                { await fetchText('https://raw.githubusercontent.com/lumither/blog-posts/master/about/website.md') }
            </MarkdownRenderer>
        </div>
    );
 };
 export default Website;
@@ -0,0 +1,92 @@
 import React from 'react';
 import { Card, CardBody, CardFooter } from '@nextui-org/card';
 import { Chip } from '@nextui-org/react';
 import Image from 'next/image';
 import Link from 'next/link';
 import { MdCalendarMonth, MdNorthEast } from 'react-icons/md';
 type Props = {
    post: JSON
 }
 function BlogPostCard({ post }: Props) {
    let title = (post as any)['title'];
    let sub_title = (post as any)['sub_title'];
    // let summary = (post as any)['summary'];
    let category = (post as any)['category'];
    let tags = (post as any)['tags'];
    // let last_update = new Date((post as any)['last_update']);
    let first_update = new Date((post as any)['first_update']);
    let post_id = (post as any)['post_id'];
    let header_img = ((post as any)['header_img'] as string | null);
    return (
        <div className={ `w-full` }>
            <Card as={ Link } href={ `/blog/post/${ post_id }` }
                  className={ `group` }
                  isPressable
                  isHoverable
            >
                { header_img && <div className={ `w-full overflow h-80 relative` }>
                    <Image
                        alt={ 'cover picture' }
                        src={ header_img }
                        className={ `w-full object-cover rounded-b-none z-10` }
                        loading={ 'eager' }
                        fill
                    ></Image>
                    <Image
                        alt={ 'cover picture shadow' }
                        src={ header_img }
                        loading={ 'eager' }
                        className={ `w-full object-cover rounded-b-none scale-y-110 blur-2xl` }
                        fill
                    ></Image>
                </div> }
                <CardBody className={ `overflow-visible` }>
                    <div className={ `flex flex-row justify-between` }>
                        <div className={ `mx-2 ${ header_img ? '-mt-6' : 'mt-2' }` }>
                            <Chip className={ `mb-2 z-30 text-lg` } radius={ `sm` } size={ 'lg' } color={ `secondary` }
                                  variant={ `solid` }>{ category }</Chip>
                            <p className={ `text-4xl font-bold` }> { title }</p>
                            <p className={ `text-xl` }> { sub_title }</p>
                        </div>
                        <MdNorthEast className={ `mt-1 mr-2` } size={ `40px` } />
                    </div>
                </CardBody>
                <CardFooter className={ 'pt-0' }>
                    <div className={ `flex flex-row flex-wrap justify-between w-full` }>
                        <div>
                            <ul className={ `flex flex-row flex-wrap` }>
                                {
                                    tags.map((tag: string, key: any) => (
                                        <li key={ key } className={ `mx-1 mb-1` }>
                                            <Chip>{ tag }</Chip>
                                        </li>
                                    ))
                                }
                            </ul>
                        </div>
                        <div className={ `flex flex-row place-content-end mb-1 items-center mx-1` }>
                            <MdCalendarMonth />
                            <p className={ `text-zinc-500 dark:text-zinc-400 ml-1` }>
                                { first_update.toLocaleString('default', {
                                    month: `long`,
                                    day: `numeric`,
                                    year: `numeric`
                                }) }
                            </p>
                        </div>
                    </div>
                </CardFooter>
            </Card>
        </div>
    );
 }
 export default BlogPostCard;
@@ -0,0 +1 @@
 // todo: create component
@@ -0,0 +1,37 @@
 'use client';
 import React from 'react';
 import { Pagination as NextUIPagination } from '@nextui-org/react';
 import { useRouter, useSearchParams } from 'next/navigation';
 import { useScreenSizeTrigger } from '@/app/public/screenSizeTrigger';
 const Pagination = ({ total }: {
    total: number,
 }) => {
    const parsePage = Number(useSearchParams().get('page'));
    const currPage = parsePage > 0 ? parsePage : 1;
    const router = useRouter();
    const isMobile = useScreenSizeTrigger('md');
    return (
        <div className={ 'w-full p-4 pt-6 flex justify-center' }>
            <NextUIPagination
                initialPage={ currPage }
                total={ total }
                siblings={ isMobile ? 0 : 1 }
                size={ isMobile ? 'sm' : 'md' }
                showControls
                showShadow
                color={ 'default' }
                variant={ 'light' }
                onChange={ (page) => {
                    router.push(`?page=${ page }`, { scroll: false });
                } }
            />
        </div>
    );
 };
 export default Pagination;
@@ -0,0 +1,42 @@
 'use server';
 import React from 'react';
 import { fetchNocturneApi } from '@/app/blog/api';
 import { MotionDiv } from '@/app/public/MotionDiv';
 import BlogPostCard from '@/app/blog/BlogPostCard';
 import { Card, CardBody } from '@nextui-org/card';
 const PostList = async ({ page }: { page: number }) => {
    try {
        const res = await fetchNocturneApi(`/blog/get_post_list?page=${ page }`);
        const posts = await res.json();
        return (
            // blog list
            <div className={ 'w-full' }>
                <ul className={ 'flex flex-col items-center w-full space-y-7' }>
                    { posts.map((post: JSON, key: number) => (
                        <li key={ key } className={ 'w-full' }>
                            <MotionDiv
                                initial={ { y: 20, opacity: 0 } }
                                animate={ { y: 0, opacity: 1 } }
                                transition={ { ease: 'easeInOut', duration: 0.5, delay: key * .2 + .25 } }
                            >
                                <BlogPostCard post={ post } />
                            </MotionDiv>
                        </li>)
                    ) }
                </ul>
            </div>
        );
    } catch (e: any) {
        return (
            // todo:  use Error.tsx
            <Card className={ `w-full` }>
                <CardBody>
                    Fatal: { e.toString() }
                </CardBody>
            </Card>);
    }
 };
 export default PostList;
@@ -0,0 +1,21 @@
 const LOCAL_ENDPOINT = process.env.API_LOCAL_URL;
 const REMOTE_ENDPOINT = process.env.API_REMOTE_URL;
 const NOCTURNE_ENDPOINT = ((isServerSide = true) => {
    if (process.env.NODE_ENV === 'production') {
        if (isServerSide) {
            return LOCAL_ENDPOINT;
        } else {
            return REMOTE_ENDPOINT;
        }
    } else {
        return LOCAL_ENDPOINT;
    }
 });
 export async function fetchNocturneApi(path: string, isServerSideRequest = true) {
    return await fetch(`${ NOCTURNE_ENDPOINT(isServerSideRequest) }${ path }`, {
        cache: 'no-cache'
    });
 }
@@ -0,0 +1,17 @@
 import React from 'react';
 function Layout({
    children
 }: {
    children: React.ReactNode;
 }) {
    return (
        <div className={ 'flex flex-auto p-7 pl-2 lg:pl-7 w-full justify-center' }>
            <main className={ 'w-full' }>
                { children }
            </main>
        </div>
    );
 }
 export default Layout;
@@ -0,0 +1,24 @@
 import PostList from '@/app/blog/PostList';
 import Pagination from '@/app/blog/Pagination';
 import { fetchNocturneApi } from '@/app/blog/api';
 async function Blog({
    searchParams
 }: {
    searchParams: Promise<{ [key: string]: string | string[] | undefined }>
 }) {
    const parsePage = Number((await searchParams)?.page);
    const currPage = parsePage > 0 ? parsePage : 1;
    const ret = await fetchNocturneApi(`/blog/get_page_count`);
    const pageCount = (await ret.json() as any)['res'] as number;
    return (
        <div className={ 'w-full min-w-full space-y-4' }>
            <PostList page={ currPage } />
            <Pagination total={ pageCount } />
        </div>
    );
 }
 export default Blog;
@@ -0,0 +1,21 @@
 'use client';
 import React from 'react';
 import { useRouter } from 'next/navigation';
 import { Button } from '@nextui-org/react';
 import { IoArrowBackOutline } from 'react-icons/io5';
 const ButtonGoBack = () => {
    const router = useRouter();
    return (
        <Button
            startContent={ <IoArrowBackOutline /> }
            variant={ 'light' }
            onClick={ () => router.back() }
        >
            { 'Back' }
        </Button>
    );
 };
 export default ButtonGoBack;
@@ -0,0 +1,96 @@
 import React from 'react';
 import MinifyPostCard from '@/app/blog/post/[id]/MinifyPostCard';
 import Link from 'next/link';
 import { FaCreativeCommons } from 'react-icons/fa6';
 type Props = {
    post: any
 }
 const Footer = (props: Props) => {
    const { post } = props;
    const adjacent_posts = post['adj'];
    const prev_post = adjacent_posts['prev'];
    const next_post = adjacent_posts['next'];
    const link = post['meta']['link'] ?? `https://lumither.com/blog/post/${ post['meta']['id'] }`;
    const author = post['meta']['author'] ?? 'Tao';
    const author_link = post['meta']['author_link'] ?? '/about';
    const post_date = new Date(post['first_update']);
    const update_date: Date | undefined = post['last_update'] ? new Date(post['last_update']) : undefined;
    const cc = post['meta']['cc'] ?? 'by-nc-sa';
    return (
        <div className={ `w-full` }>
            <div className={ 'flex transition bg-zinc-300/80 dark:bg-gray-600/25' }>
                <div className={ `p-8 w-full overflow-hidden` }>
                    <div className={ 'relative' }>
                        <FaCreativeCommons
                            size={ '160px' }
                            className={ 'absolute right-0 top-0 -mt-[4.8rem] -mr-16 opacity-30 brightness-50  ' }
                        />
                    </div>
                    <div className={ 'flex flex-col space-y-4 relative' }>
                        <div className={ 'z-[2]' }>
                            <p className={ 'text-xl font-bold' }>{ post['meta']['title'] }</p>
                            <Link href={ link }>
                                <p className={ 'text-sm underline decoration-indigo-500 dark:decoration-sky-500' }>{ link }</p>
                            </Link>
                        </div>
                        <div className={ 'z-[2] flex flex-row flex-wrap gap-x-7 gap-y-2' }>
                            <div>
                                <p className={ 'text-lg font-bold' }>Author</p>
                                <Link href={ author_link }>
                                    <p className={ 'underline decoration-indigo-500 dark:decoration-sky-500' }>{ author }</p>
                                </Link>
                            </div>
                            <div>
                                <p className={ 'text-lg font-bold' }>Posted on</p>
                                <p>{ post_date.toLocaleString('default', {
                                    month: `long`,
                                    day: `numeric`,
                                    year: `numeric`
                                }) }</p>
                            </div>
                            { update_date &&
                                <div>
                                    <p className={ 'text-lg font-bold' }>Updated on</p>
                                    <p>{ update_date.toLocaleString('default', {
                                        month: `long`,
                                        day: `numeric`,
                                        year: `numeric`
                                    }) }</p>
                                </div>
                            }
                            <div>
                                <p className={ 'text-lg font-bold' }>Published under</p>
                                <Link href={ `https://creativecommons.org/licenses/${ cc }/4.0/` }>
                                    <p className={ 'underline decoration-indigo-500 dark:decoration-sky-500' }>{ `CC ${ cc.toUpperCase() } 4.0` }</p>
                                </Link>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
            <div className={ `flex justify-center` }>
                <div className={ `w-full shadow-2xl ` }>
                    <div className={ `flex flex-col md:flex-row w-full` }>
                        {
                            next_post &&
                            <MinifyPostCard post={ next_post } desc={ 'prev' }></MinifyPostCard>
                        }
                        {
                            prev_post &&
                            <MinifyPostCard post={ prev_post } desc={ 'next' }></MinifyPostCard>
                        }
                    </div>
                </div>
            </div>
        </div>
    );
 };
 export default Footer;
@@ -0,0 +1,80 @@
 import React from 'react';
 import Image from 'next/image';
 import { Chip } from '@nextui-org/react';
 import { MdCalendarMonth } from 'react-icons/md';
 type Props = {
    post: any
 };
 const Headers = (props: Props) => {
    let post = props.post;
    let title = post['title'];
    let sub_title = post['sub_title'];
    // let summary = (post as any)['summary'];
    let category = post['category'];
    let tags = post['tags'];
    // let last_update = new Date((post as any)['last_update']);
    let first_update = new Date(post['first_update']);
    // let post_id = (post as any)['post_id'];
    let header_img = post['meta']['header_img'] as string | null;
    return (
        <>
            { header_img && <div className={ `w-full overflow h-96 relative` }>
                <Image
                    alt={ 'cover picture' }
                    src={ header_img }
                    className={ `w-full object-cover rounded-b-none z-[5]` }
                    fill
                ></Image>
                <Image
                    alt={ 'cover picture' }
                    src={ header_img }
                    className={ `w-full relative scale-110 blur-3xl object-cover rounded-b-none` }
                    fill
                ></Image>
            </div> }
            <div
                className={ header_img ?
                    'mx-8 -mt-16 backdrop-blur transition bg-zinc-300/80 dark:bg-gray-600/25 rounded-2xl z-30'
                    : 'mx-6 mt-6'
                }>
                <div className={ header_img ? `p-4` : 'p-4 pt-2' }>
                    <Chip className={ `mb-2` } radius={ `sm` } color={ `secondary` }
                          variant={ `solid` }>{ category }</Chip>
                    <p className={ `text-4xl font-bold` }> { title }</p>
                    <p className={ `text-xl` }> { sub_title }</p>
                </div>
                <div className={ `mx-2 -mt-2 mb-2 flex flex-row flex-wrap justify-between w-full` }>
                    <div>
                        <ul className={ `flex flex-row flex-wrap` }>
                            {
                                tags.map((tag: string, key: any) => (
                                    <li key={ key } className={ `mx-1 mb-1` }>
                                        <Chip>{ tag }</Chip>
                                    </li>
                                ))
                            }
                        </ul>
                    </div>
                    <div className={ `flex flex-row place-content-end mb-1 mr-6 items-center mx-1` }>
                        <MdCalendarMonth />
                        <p className={ `text-zinc-500 dark:text-zinc-400 ml-1` }>
                            { first_update.toLocaleString('default', {
                                month: `long`,
                                day: `numeric`,
                                year: `numeric`
                            }) }
                        </p>
                    </div>
                </div>
            </div>
        </>
    );
 };
 export default Headers;
@@ -0,0 +1,58 @@
 import React from 'react';
 import { Card, CardFooter, CardHeader } from '@nextui-org/card';
 import Image from 'next/image';
 import Link from 'next/link';
 type Props = {
    post: any
    desc: string
 }
 const MinifyPostCard = (props: Props) => {
    const { post, desc } = props;
    const img_url = post['header_img'] as string;
    return (
        <div className={ 'w-full transition hover:brightness-75' }>
            <Card isFooterBlurred
                  className="w-full h-[300px] shadow-none border-0 rounded-none overflow-hidden"
                  as={ Link }
                  isPressable
                  href={ `/blog/post/${ post['id'] }` }
            >
                <CardHeader className="absolute z-10 top-1 flex-col items-start">
                    <p className={ `text-tiny uppercase font-bold ${ img_url ? 'text-white/60' : 'text-black/60 dark:text-white/60' }` }>{ desc }</p>
                </CardHeader>
                { img_url &&
                    <div className={ 'h-full' }>
                        <div className={ 'relative h-[300px] overflow-hidden' }>
                            <Image
                                className={ 'object-cover object-center ' }
                                src={ img_url }
                                alt={ post.title }
                                fill
                            />
                        </div>
                        <CardFooter
                            className="absolute transition-colors bg-zinc-300/80 dark:bg-gray-600/25 dark:backdrop-brightness-75 bottom-0  justify-between rounded-none">
                            <div>
                                <p className="text-2xl font-bold">{ post['title'] }</p>
                                <p className="">{ post['sub_title'] }</p>
                            </div>
                        </CardFooter>
                    </div>
                }
                { !img_url &&
                    <div className={ 'h-full grid p-6 place-content-center' }>
                        <div className={ 'flex flex-row  items-center text-center max-h-fit' }>
                            <p className={ 'text-3xl font-bold' }>{ post['title'] }</p>
                            <div className={ 'h-full w-1 mx-2 bg-zinc-500 dark:bg-zinc-400' }></div>
                            <p className={ 'text-xl' }>{ post['sub_title'] }</p>
                        </div>
                    </div>
                }
            </Card>
        </div>
    );
 };
 export default MinifyPostCard;
@@ -0,0 +1,53 @@
 import React from 'react';
 import { Card, CardBody } from '@nextui-org/card';
 import Headers from '@/app/blog/post/[id]/Headers';
 import Footer from '@/app/blog/post/[id]/Footer';
 import { fetchNocturneApi } from '@/app/blog/api';
 import MarkdownRenderer from '@/app/public/MarkdownRenderer';
 type Props = {
    id: string
 }
 async function PostCard(props: Props) {
    try {
        const res = await fetchNocturneApi(`/blog/get_post/${ props.id }`);
        const ret: any = await res.json();
        return (
            <div>
                <Card className={ `max-w-full relative` }>
                    {/* card headers */ }
                    <Headers post={ ret } />
                    {/* card body */ }
                    <CardBody>
                        <div className={ 'p-5' }>
                            <MarkdownRenderer>
                                { ret['content'] }
                            </MarkdownRenderer>
                        </div>
                    </CardBody>
                    {/* card footer */ }
                    <Footer post={ ret } />
                </Card>
            </div>
        );
    } catch (e: any) {
        return <div>
            <Card className={ `w-full` }>
                <CardBody>
                    Fatal: { e.toString() }
                </CardBody>
            </Card>
        </div>;
    }
 }
 export default PostCard;
@@ -0,0 +1,29 @@
 import React from 'react';
 import PostCard from '@/app/blog/post/[id]/PostCard';
 import { MotionDiv } from '@/app/public/MotionDiv';
 import ButtonGoBack from '@/app/blog/post/[id]/ButtonGoBack';
 async function BlogReader({
    params
 }: {
    params: Promise<{ id: string }>
 }) {
    return (
        <MotionDiv
            className={ `max-w-full` }
            initial={ { y: 20, opacity: 0 } }
            animate={ { y: 0, opacity: 1 } }
            transition={ { ease: 'easeInOut', duration: 0.5 } }
        >
            <div className={ `max-w-full` }>
                <PostCard id={ (await params).id } />
            </div>
            <div className={ 'mt-3' }>
                <ButtonGoBack />
            </div>
        </MotionDiv>
    );
 }
 export default BlogReader;
@@ -0,0 +1,17 @@
 export async function fetchText(url: string, ttl: number = 600) {
    const res = await fetch(url, {
        next: {
            revalidate: ttl
        }
    });
    return await res.text();
 }
 export async function fetchJson(url: string, ttl: number = 600) {
    const res = await fetch(url, {
        next: {
            revalidate: ttl
        }
    });
    return await res.json();
 }
@@ -0,0 +1,15 @@
 import React from 'react';
 function Layout({
    children
 }: {
    children: React.ReactNode;
 }) {
    return (
        <div className={ 'p-7' }>
            { children }
        </div>
    );
 }
 export default Layout;
@@ -0,0 +1,93 @@
 import React from 'react';
 import { fetchJson } from '@/app/fetch';
 import { Card, CardBody } from '@nextui-org/react';
 import Image from 'next/image';
 import Link from 'next/link';
 export default async function Friends() {
    const list = await fetchJson('https://raw.githubusercontent.com/Lumither/friends/master/friends.json');
    const listLength = list.length;
    const listMaxIdx = listLength - 1;
    const listIsOdd = listLength % 2 !== 0;
    return (
        <div>
            <div className={ `min-h-dvh pb-10` }>
                <div className={ 'p-7 pt-[10%] md:pt-[20%]' }>
                    <div className={ 'flex flex-col md:flex-row gap-x-3 justify-center' }>
                        <p className={ 'text-3xl text-center text-balance' }>海内存知己</p>
                        <p className={ 'text-3xl text-center text-balance' }>天涯若比邻</p>
                    </div>
                    <p className={ 'text-center text-balance text-zinc-500 dark:text-zinc-400' }>{ 'Though far apart, kin at heart' }</p>
                </div>
                <div className={ 'flex w-full h-full justify-center pt-3' }>
                    <ul className={ 'grid grid-cols-2 gap-x-6 gap-y-3 md:max-w-[90%] xl:max-w-[85%] w-full' }>
                        {
                            list.map((friend: any, key: number) => (
                                <li
                                    key={ key }
                                    className={ (key === listMaxIdx && listIsOdd) ? 'col-span-2 flex justify-center' : 'col-span-2 md:col-span-1' }
                                >
                                    <Card
                                        isHoverable
                                        isPressable
                                        shadow={ 'none' }
                                        as={ Link }
                                        href={ friend['url'] }
                                        className={ 'dark:bg-[#282830] w-full md:w-fit max-w-full shadow' }
                                    >
                                        <CardBody className={ 'overflow-visible pb-0.5' }>
                                            <div className={ 'flex flex-row' }>
                                                <div className={ 'flex p-2' }>
                                                    <div
                                                        className={ 'h-[80px] w-[80px] relative rounded-2xl' }>
                                                        <Image
                                                            alt="avatar"
                                                            className="object-cover rounded-2xl z-10"
                                                            fill
                                                            unoptimized
                                                            src={ friend['avatar'] }
                                                        />
                                                        <Image
                                                            alt="avatar"
                                                            className="relative object-cover rounded-2xl scale-110 blur-3xl"
                                                            fill
                                                            unoptimized
                                                            src={ friend['avatar'] }
                                                        />
                                                    </div>
                                                </div>
                                                <div className={ 'p-2 flex-col max-w-full' }>
                                                    <p className={ 'text-xl' }>{ friend['title'] }</p>
                                                    { (friend['name'] === undefined || friend['name'].isNull) ??
                                                        <p className={ 'text-zinc-600 dark:text-zinc-400' }>{ `@ ${ friend['name'] }` }</p> }
                                                    { (friend['desc'] === undefined || friend['desc'].isNull) ??
                                                        <p className={ 'text-sm text-pretty text-zinc-600 dark:text-zinc-300 mt-1' }>{ friend['desc'] }</p> }
                                                </div>
                                            </div>
                                        </CardBody>
                                        <div className={ 'h-2 relative w-full' }>
                                            <Image
                                                alt="theme bar"
                                                draggable={ false }
                                                className="object-cover object-center scale-110 blur-lg"
                                                fill
                                                unoptimized
                                                src={ friend['avatar'] }
                                            />
                                        </div>
                                    </Card>
                                </li>
                            ))
                        }
                    </ul>
                </div>
            </div>
            <p className={ 'text-center' }>想要成为好伙伴嘛，向<span
                className={ 'text-blue-800 dark:text-blue-500' }><Link
                href={ 'https://github.com/Lumither/friends/' }>这里</Link></span>发起PR吧
            </p>
        </div>
    );
 }
@@ -0,0 +1,13 @@
@import "lxgw-wenkai-webfont/style.css";
@tailwind base;
@tailwind components;
@tailwind utilities;
 body {
    font-family: "LXGW WenKai", sans-serif;
 }
 pre, code {
    font-family: "LXGW WenKai Mono", sans-serif;
 }
@@ -0,0 +1,34 @@
 import type { Metadata } from 'next';
 import './globals.css';
 import React from 'react';
 import { ThemeProvider as NextThemesProvider } from 'next-themes';
 import Navbar from '@/components/Navbar';
 import Footer from '@/components/Footer';
 export const metadata: Metadata = {
    title: 'Lumitherの酒馆',
    description: '一间位于时间夹缝中的酒馆，静候下一位旅者的到来...'
 };
 export default function RootLayout({
    children
 }: Readonly<{
    children: React.ReactNode;
 }>) {
    return (
        <html lang="en" suppressHydrationWarning>
        <body className={ `transition duration-300 dark:bg-[#282830] min-h-screen` }>
        <NextThemesProvider attribute="class" defaultTheme="system">
            <div className={ `justify-center flex flex-row w-full max-w-full` }>
                <Navbar />
                <div className={ `flex flex-col flex-1 max-w-[1024px] min-w-0` }>
                    { children }
                    <Footer />
                </div>
            </div>
        </NextThemesProvider>
        </body>
        </html>
    );
 }
@@ -0,0 +1,10 @@
 import ConstructionPlaceHolder from '@/components/ConstructionPlaceHolder';
 import React from 'react';
 export default function Home() {
    return (
        <div className={ `h-dvh` }>
            <ConstructionPlaceHolder />
        </div>
    );
 }
@@ -0,0 +1,64 @@
 import React from 'react';
 import Markdown from 'react-markdown';
 import remarkGfm from 'remark-gfm';
 import remarkToc from 'remark-toc';
 import remarkFrontmatter from 'remark-frontmatter';
 import rehypeRaw from 'rehype-raw';
 import rehypeSanitize from 'rehype-sanitize';
 import { Prism as SyntaxHighlighter } from 'react-syntax-highlighter';
 import { oneDark } from 'react-syntax-highlighter/dist/esm/styles/prism';
 const MarkdownRenderer = ({ children }: { children: React.ReactNode }) => {
    return (
        <div className={ 'w-full' }>
            <Markdown
                className={ `max-w-full text-justify text-pretty prose prose-sm prose-neutral dark:prose-invert
                 md:prose-md lg:prose-lg prose-code:overflow-x-scroll`
                }
                remarkPlugins={ [ remarkGfm, remarkToc, remarkFrontmatter ] }
                rehypePlugins={ [ rehypeRaw, rehypeSanitize ] }
                components={ {
                    pre(props) {
                        const { node, className, children, ...rest } = props;
                        if ((children as any)['type'] === 'code') {
                            const match = /language-(\w+)/.exec((children as any)['props']['className'] || '');
                            let lang = match ? match[1] : 'text';
                            return (
                                <pre className={ `not-prose` }>
                                    <SyntaxHighlighter
                                        // @ts-ignore
                                        style={ oneDark }
                                        language={ lang }
                                        showLineNumbers
                                        // wrapLongLines
                                        // wrapLines
                                        classNames={ className }
                                        PreTag="div"
                                        { ...rest }
                                    >
                                        {
                                            String((children as any)['props']['children']).replace(/\n$/, '')
                                        }
                                    </SyntaxHighlighter>
                                </pre>
                            );
                        } else {
                            return (
                                <pre className={ `not-prose` }>
                                    <code className={ className } { ...props }>
                                        { children }
                                    </code>
                               </pre>
                            );
                        }
                    }
                } }
            >
                {
                    children as any
                }
            </Markdown>
        </div>
    );
 };
 export default MarkdownRenderer;
@@ -0,0 +1,5 @@
 'use client';
 import { motion } from 'framer-motion';
 export const MotionDiv = motion.div;
@@ -0,0 +1,35 @@
 import { useEffect, useState } from 'react';
 const screenSize = new Map<string, number>(
    [
        [ 'sm', 640 ],
        [ 'md', 768 ],
        [ 'lg', 1024 ],
        [ 'xl', 1280 ],
        [ '2xl', 2536 ]
    ]
 );
 export const useScreenSizeTrigger = (size: number | string) => {
    const criticalSize = (typeof size === 'string') ? (screenSize.get(size) ?? 768) : size;
    const [ isCritical, setIsCritical ] = useState(false);
    useEffect(() => {
        const updateMobileWidth = () => {
            if (window.innerWidth < criticalSize) {
                setIsCritical(true);
            } else {
                setIsCritical(false);
            }
        };
        updateMobileWidth();
        window.addEventListener('resize', updateMobileWidth);
        return () => {
            window.removeEventListener('resize', updateMobileWidth);
        };
    });
    return isCritical;
 };
@@ -0,0 +1,13 @@
 import React from 'react';
 import ConstructionPlaceHolder from '@/components/ConstructionPlaceHolder';
 const Search = () => {
    return (
        <div className={ `h-dvh` }>
            <ConstructionPlaceHolder />
        </div>
    );
 };
 export default Search;
@@ -0,0 +1,13 @@
 import React from 'react';
 const ConstructionPlaceHolder = () => {
    return (
        <div className={ `flex h-full w-full justify-center items-center` }>
            <p className={ `text-2xl font-bold` }>
                正在施工中...
            </p>
        </div>
    );
 };
 export default ConstructionPlaceHolder;
@@ -0,0 +1,25 @@
 import React from 'react';
 import Link from 'next/link';
 import { IoLogoGithub } from 'react-icons/io5';
 const Footer = () => {
    return (
        <div className={ `p-5 mb-4` }>
            <div className={ `h-1 w-20 bg-zinc-500 dark:bg-zinc-400 mb-3` }></div>
            <p>
                © 2024-{ new Date().getFullYear() } <Link href={ `/about` }>Lumither Tao</Link>
            </p>
            <p>
                Powered by Next.js and Rust, built with passion and love
            </p>
            <Link
                href={ `https://github.com/Lumither/blog` }
                aria-label={ `GitHub repo for this website` }
            >
                <IoLogoGithub className={ `mt-1` } />
            </Link>
        </div>
    );
 };
 export default Footer;
@@ -0,0 +1,169 @@
 'use client';
 import React, { useEffect, useState } from 'react';
 import { Button } from '@nextui-org/react';
 import Image from 'next/image';
 import {
    IoFlask,
    IoHome,
    IoInformationCircle,
    IoLink,
    IoLogoGithub,
    IoMail,
    IoPencil,
    IoSearch
 } from 'react-icons/io5';
 import Link from 'next/link';
 import ThemeSwitcher from '@/components/ThemeSwitcher';
 import { usePathname } from 'next/navigation';
 import { useScreenSizeTrigger } from '@/app/public/screenSizeTrigger';
 const entries: { display_name: string; href: string; icon: React.ReactNode }[] = [
    {
        icon: <IoHome size={ `20px` }></IoHome>,
        display_name: 'Home',
        href: '/'
    },
    {
        icon: <IoInformationCircle size={ `20px` }></IoInformationCircle>,
        display_name: 'About',
        href: '/about'
    },
    {
        icon: <IoPencil size={ `20px` }></IoPencil>,
        display_name: 'Blog',
        href: '/blog'
    },
    {
        icon: <IoLink size={ `20px` }></IoLink>,
        display_name: 'Friends',
        href: '/friends'
    },
    {
        icon: <IoSearch size={ `20px` }></IoSearch>,
        display_name: 'Search',
        href: '/search'
    }, {
        icon: <IoFlask size={ '20px' } />,
        display_name: 'Lab',
        href: 'https://lab.lmt.moe'
    }
 ];
 const connections: { label: string, href: string, icon: React.ReactNode }[] = [
    {
        label: 'Github',
        href: 'https://github.com/Lumither',
        icon: <IoLogoGithub size={ `30px` } />
    },
    {
        label: 'email',
        href: 'mailto:lumither@outlook.com',
        icon: <IoMail size={ `30px` } />
    }
 ];
 function Navbar() {
    const path = usePathname();
    const [ shownPath, setShownPath ] = useState(path);
    useEffect(() => {
        let trimmed_path = path.split(`/`)[1];
        if (trimmed_path === '') {
            setShownPath('HOME');
        } else {
            setShownPath(trimmed_path.toUpperCase());
        }
    }, [ path ]);
    const isMobile = useScreenSizeTrigger('lg');
    return (
        <>
            <div
                className={ `flex flex-col min-w-[50px] lg:min-w-[200px] ml-2 mr-0 lg:ml-8 lg:mr-6 min-h-screen pt-8 sticky` }>
                <div className={ `fixed min-h-screen h-full` }>
                    <div className={ `hidden lg:block` }>
                        <div className={ `flex justify-center items-center my-7 h-[200px] w-[200px]` }>
                            <div className={ 'relative w-full h-full' }>
                                <Image
                                    src={ 'https://oss.lumither.com/blog/pictures/avatar.webp' }
                                    alt={ 'avatar' }
                                    fill
                                    className={ 'rounded-full object-cover' }
                                    loading={ 'eager' }
                                ></Image>
                            </div>
                        </div>
                        <div>
                            <p className={ `font-bold text-2xl` }>Lumither Tao</p>
                            <p className={ `text-xl text-zinc-500 dark:text-zinc-400` }>Ad Astra</p>
                        </div>
                    </div>
                    <div>
                        <ul className={ `flex flex-col space-y-2 lg:space-y-0 lg:flex-row items-center my-4 lg:space-x-2` }>
                            {
                                connections.map((conn, key) => (
                                    <li key={ key }>
                                        <Button as={ Link }
                                                href={ conn.href }
                                                aria-label={ conn.label }
                                                variant={ `light` }
                                                color={ `default` }
                                                className={ `w-fit` }
                                                isIconOnly
                                        >
                                            { conn.icon }
                                        </Button>
                                    </li>
                                ))
                            }
                        </ul>
                    </div>
                    <div
                        className={ `flex justify-center lg:justify-start w-full mt-8 ml-0 lg:-ml-3` }>
                        <ul className={ `flex flex-col space-y-2 w-full` }>
                            {
                                entries.map((meta, key) => (
                                    <li key={ key }>
                                        <Button
                                            as={ Link }
                                            variant={ `light` }
                                            color={ `default` }
                                            fullWidth
                                            isIconOnly={ isMobile }
                                            className={ 'flex lg:justify-start w-fit lg:w-full' }
                                            aria-label={ `navbar: ${ meta.display_name }` }
                                            href={ meta.href }
                                        >
                                            { meta.icon }
                                            <p className={ `font-bold hidden lg:block` }>{ meta.display_name }</p>
                                        </Button>
                                    </li>
                                ))
                            }
                        </ul>
                    </div>
                    <div className={ `mt-8 flex lg:hidden justify-center w-full` }>
                        <p className={ `text-center sideways-lr font-bold text-2xl text-zinc-500 dark:text-zinc-400` }>
                            { shownPath }
                        </p>
                    </div>
                    <div
                        className={ `absolute bottom-16` }
                    >
                        <ThemeSwitcher />
                    </div>
                </div>
            </div>
        </>
    );
 }
 export default Navbar;
@@ -0,0 +1,93 @@
 'use client';
 import React, { useEffect, useState } from 'react';
 import { useTheme } from 'next-themes';
 import { Button, Dropdown, DropdownItem, DropdownMenu, DropdownTrigger } from '@nextui-org/react';
 import { MdOutlineDarkMode, MdOutlineDesktopWindows, MdOutlineLightMode } from 'react-icons/md';
 import { useScreenSizeTrigger } from '@/app/public/screenSizeTrigger';
 const switcherElements = new Map(
    [
        [ 'dark', {
            'display_name': 'Dark Mode',
            'icon': <MdOutlineDarkMode />
        } ],
        [ 'light', {
            'display_name': 'Light Mode',
            'icon': <MdOutlineLightMode />
        } ],
        [ 'system', {
            'display_name': 'Follow System',
            'icon': <MdOutlineDesktopWindows />
        } ]
    ]
 );
 function ThemeSwitcher() {
    const [ mounted, setMounted ] = useState(false);
    const { theme, setTheme } = useTheme();
    const [ currTheme, setCurrTheme ] = useState(new Set([ theme as string ]));
    const isMobile = useScreenSizeTrigger('lg');
    useEffect(() => {
        setMounted(true);
    }, []);
    if (!mounted) {
        return null;
    }
    return (
        <div className={ `` }>
            <Dropdown backdrop={ 'blur' }>
                <DropdownTrigger>
                    <Button
                        variant={ 'flat' }
                        aria-label={ 'Theme Trigger' }
                        fullWidth
                        isIconOnly={ isMobile }
                    >
                        { switcherElements.get(currTheme.values().next().value as string)?.icon }
                        <p className={ 'hidden lg:block' }>
                            { switcherElements.get(currTheme.values().next().value as string)?.display_name }
                        </p>
                    </Button>
                </DropdownTrigger>
                <DropdownMenu
                    aria-label={ 'Toggle Theme' }
                    variant={ 'flat' }
                    selectionMode={ 'single' }
                    selectedKeys={ currTheme }
                    onSelectionChange={ ({ anchorKey }) => {
                        setCurrTheme(new Set([ anchorKey as string ]));
                        setTheme(anchorKey as string);
                    } }
                >
                    <DropdownItem
                        key={ 'light' }
                        startContent={ <MdOutlineLightMode /> }>
                        Light Mode
                    </DropdownItem>
                    <DropdownItem
                        key={ 'dark' }
                        startContent={ <MdOutlineDarkMode /> }
                    >
                        Dark Mode
                    </DropdownItem>
                    <DropdownItem
                        key={ 'system' }
                        startContent={ <MdOutlineDesktopWindows /> }
                    >
                        Follow System
                    </DropdownItem>
                </DropdownMenu>
            </Dropdown>
        </div>
    );
 }
 export default ThemeSwitcher;
@@ -0,0 +1,18 @@
 /** @type {import('next').NextConfig} */
 const nextConfig = {
    images: {
        remotePatterns: [
            {
                protocol: 'https',
                hostname: 'oss.lumither.com'
            },
            {
                protocol: 'https',
                hostname: 'pic.re'
            }
        ]
    },
    output: 'standalone'
 };
 export default nextConfig;
Author	SHA1	Message	Date
lumither	d6c7602123	git(global) create release branch	2025-04-13 03:52:03 -07:00
lumither	6da6231c92	feat(lab) add link to lab	2024-12-10 04:00:57 -08:00
lumither	19f84d2188	fix(blog::post::footer) remove update_date section if undefined	2024-12-10 04:00:10 -08:00
lumither	20c2964242	feat(container) production build	2024-12-08 22:25:47 -08:00
lumither	eac84307bf	Merge pull request #1 from Lumither/backend-refactor Backend refactor	2024-12-01 02:39:00 -08:00
lumither	a0dc40d2ca	feat(blog::api) fix apis, frontend	2024-12-01 02:35:13 -08:00
lumither	cbc831bb70	fix(cron::update) fix several errors	2024-11-27 04:00:38 -08:00
lumither	bacaea80a3	feat(cron::update) auto update git repo and update db index	2024-11-27 00:18:08 -08:00
lumither	99a19d8d9e	feat(init::schema) init database schema	2024-11-20 21:38:36 -08:00
lumither	7f400470ff	feat(cron) call the module	2024-11-20 19:26:33 -08:00
lumither	e26003f430	ref(global) move modules, extract constants	2024-11-20 00:57:54 -08:00
lumither	c7e3b12856	feat(macros) add `panic_with_log`	2024-11-19 00:33:09 -08:00
lumither	a123ff9f3f	fix(scheduler) fn type	2024-11-17 21:06:36 -08:00
lumither	d98aa3f745	fix(scheduler) remove unnecessary field	2024-10-30 23:07:22 -07:00
lumither	6f45a140ba	ref(scheduler) move module	2024-10-30 22:54:39 -07:00
lumither	3dab27323a	ref, feat(scheduler) global project refactor, add scheduler	2024-10-29 18:37:14 -07:00
lumither	3baf011be9	feat(backend) improve logger.rs	2024-09-08 00:05:14 -07:00
lumither	c1ba41ea16	ref(backend) start of refactor	2024-09-04 23:18:41 -07:00
lumither	3c1fc34c2a	feat(nav, blog) new ThemeSwitcher, also several updates on ui	2024-08-19 01:22:27 +08:00
lumither	2ca7e8bc14	feat(friends) style update	2024-08-17 03:14:53 +08:00
lumither	ffc29d8bc5	feat(global) several major updates: - delete page `tag`, `archive` - add page `friends` - implement page `about` partially	2024-08-16 23:10:59 +08:00
lumither	695e8b574e	fix(blog) remove debug constant	2024-08-13 22:49:57 +08:00
lumither	04e1d0a508	fix(blog) remove console.log	2024-08-13 22:36:09 +08:00
lumither	eb7ea991ac	feat(blog) pagination	2024-08-13 22:32:27 +08:00
lumither	9f72bb01b7	feat(global) container and project structure update	2024-08-13 22:32:04 +08:00
lumither	fbc9736831	feat(global) containerize	2024-08-01 01:39:24 +08:00
lumither	36f686c563	feat(blog) add footer for post reading part	2024-07-26 19:30:43 +08:00
lumither	dbe84bc9f4	feat(blog) add `adj` (adjacent posts) to get_post	2024-07-25 00:37:10 +08:00
lumither	91ad20215a	feat(blog) add `meta` to get_post	2024-07-23 02:49:16 +08:00
lumither	ee413c5dee	feat(blog) add pagination for get_post_list	2024-07-22 21:33:20 +08:00
lumither	1917630265	feat(blog) add force refresh	2024-07-22 19:59:57 +08:00
lumither	67f9cd0b1d	feat(blog) add implementation for table meta	2024-07-21 23:09:13 +08:00
lumither	0864f0b950	feat(blog::refresh) add hash check to boost idx speed	2024-07-21 01:12:15 +08:00
lumither	de27479242	feat(post) add header, fix style	2024-07-18 21:02:37 +08:00
lumither	d982bf0548	feat(global) better logging, add several fields for `get_post` api - add sub_title, category, header_img to `get_post`	2024-07-01 17:21:28 +08:00
lumither	371f3cab39	fix(.env) clean env	2024-06-27 02:32:56 +08:00
lumither	74945fe0bb	fix(.env) fix deployment	2024-06-27 02:29:27 +08:00
lumither	ddfe0701af	feat(log) add logging system	2024-06-20 23:41:08 +08:00
lumither	9081e9a86d	feat(log) add logrotate	2024-06-19 00:01:20 +08:00
lumither	ef0f6b335e	docs(README.md) regular update	2024-06-18 14:26:10 +08:00
lumither	59f23e8672	feat(CI/CD) add scripts	2024-06-18 14:25:36 +08:00
lumither	6b75c17b05	ref(global) update project structure	2024-06-18 13:07:40 +08:00
lumither	2fabd8d5c0	feat(env) env update	2024-06-08 02:31:20 +08:00
lumither	c62fe7d1ef	feat(bolg) add animation	2024-06-06 19:13:25 +08:00
lumither	56d673a9ec	feat(global) new api rule, NextImage support, test openresty	2024-06-05 01:57:18 +08:00
lumither	ffb20b64f3	feat(Navbar) update avatar, font	2024-05-31 22:18:03 +08:00
lumither	bb657545c3	feat(navbar) update navbar	2024-05-30 15:47:55 +08:00
lumither	3f38a6366b	fix(blog) fix style	2024-05-29 21:52:01 +08:00
lumither	a59f6d7ae0	feat(navbar) update navbar	2024-05-29 18:36:55 +08:00
lumither	99d76f0a8c	feat(blog) add footer	2024-05-29 18:36:16 +08:00
lumither	b4007b6c6e	feat(blog) fix style	2024-05-29 18:35:53 +08:00
lumither	bfee26609e	feat(navbar) add fix style	2024-05-27 23:35:29 +08:00
lumither	d855df0d6e	feat(navbar) new style, better performance	2024-05-25 23:20:12 +08:00
lumither	60a4a88246	fix(frontend/blog) fix compatability	2024-05-12 23:03:17 +08:00
lumither	1a2932a194	ref(backend/api/get/get_post_list) add category, header_img	2024-05-12 23:02:33 +08:00
lumither	fd8b760b7f	ref(backend) major refactor - remove struct Post, use database schema and Map instead - add sub_title - replace NaiveDateTime with DateTime<Utc>	2024-05-12 17:00:37 +08:00
lumither	7d856f25a3	fix(frontend/blog) fix category chip z-axis height	2024-05-12 12:18:03 +08:00
lumither	a11d859f40	feat(frontend/blog) even better post card	2024-05-12 12:11:33 +08:00
lumither	fd4bdb4a6f	feat(frontend/blog) font, lighthouse improve	2024-05-09 22:35:01 +08:00
lumither	7e0b015cbc	feat(frontend/blog) better post card	2024-05-09 17:31:21 +08:00
lumither	85d474e902	fix(frontend/blog) fix style	2024-05-05 00:53:54 +08:00
lumither	ac84a6acb5	feat(backend/api/get/post) fix error handling	2024-05-04 22:55:45 +08:00
lumither	a4d0b7140a	fix(frontend/blog/post) fix compatibility with new backend - switch to axios	2024-05-04 22:54:38 +08:00
lumither	4f09648a34	feat(backend/api/get/post/<post_id>) implement api	2024-05-04 21:06:01 +08:00
lumither	131789bf83	feat(backend/post) new id strategy	2024-05-04 15:55:00 +08:00
lumither	4e71a1ccf0	feat(backend/api/get/post_list) add `first_update` field	2024-05-04 14:02:54 +08:00
lumither	7e3687c4c9	feat(backend/database/post) add first_update	2024-05-04 13:16:03 +08:00
lumither	a9ba365bac	fix(frontend/Blog) fix compatibility with new backend	2024-05-04 00:51:32 +08:00
lumither	b17e8a19eb	feat(api) update /api/get/post_list	2024-05-04 00:35:47 +08:00
lumither	5d82152932	feat(api) finish /api/get/post_list	2024-05-03 23:43:19 +08:00
lumither	70016f508f	feat(idx) finish idx system	2024-05-03 22:42:14 +08:00
lumither	36825b4950	feat(idx) add auto idx	2024-05-03 21:40:53 +08:00
lumither	6b311ab255	feat(readme) update README.md	2024-05-03 14:36:09 +08:00
lumither	2d42e933c8	feat(api) add refresh.rs	2024-05-03 02:17:11 +08:00
lumither	dce7a28b89	feat(project) add refresh.sh	2024-05-02 22:12:13 +08:00
lumither	1668de832f	feat(backend) backed init	2024-05-02 19:02:13 +08:00
lumither	a685537499	feat(reader) add reader	2024-04-30 00:40:59 +08:00
		`@@ -0,0 +1,3 @@`
							`pub trait TaskFunc: Fn() + Send + Sync + 'static {}`

							`impl<T> TaskFunc for T where T: Fn() + Send + Sync + Clone + 'static {}`
		`@@ -0,0 +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";`