I just Starting to learn Rust

Naufal Rabbani — Sun, 04 Jan 2026 05:18:24 +0000

I just want to paste all the notes or snippet here.

no explanation at all, just put many references and how I implement it.

use axum::{
    Json, Router,
    extract::State,
    http::StatusCode,
    routing::{get, post},
};
use rusqlite::Connection;
use serde::{Deserialize, Serialize};
use std::sync::{Arc, Mutex};
// use std::thread;
use tokio::task;

// Ref: how to use app state: https://users.rust-lang.org/t/how-to-pass-app-state-in-axum/104458/3

// define local module. the file at app_infra/mod.rs
mod app_infra;

#[derive(Debug, Clone)]
struct AppState {
    // Ref: how to make un-clonable object in external mod implementing Clone traits
    // here the link: https://itsallaboutthebit.com/arc-mutex/
    // Arc: will let the data / object shared between threads
    // Mutex: ensure only 1 thread at a time can access the data / object
    db: Arc<Mutex<Connection>>,
}

#[tokio::main]
async fn main() {
    // initialize tracing
    tracing_subscriber::fmt::init();

    let db = match app_infra::create_db_connection() {
        Ok(conn) => conn,
        Err(err) => panic!("error to connect to db {}", err.to_string()),
    };
    let cloneable_db = Arc::new(Mutex::new(db));

    let app_state = AppState { db: cloneable_db };

    // build our application with a route
    let app = Router::new()
        // `GET /` goes to `root`
        .route("/", get(root))
        // `POST /users` goes to `create_user`
        .route("/users", post(create_user))
        .with_state(app_state);

    // run our app with hyper, listening globally on port 3000
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

// basic handler that responds with a static string
async fn root(State(AppState { db }): State<AppState>) -> &'static str {
    let outside_int = 213123i32;

    // let mut all_item: Vec<String> = Vec::new();
    // ref: https://itsallaboutthebit.com/arc-mutex/
    // this is how to lock our mutex object
    // ref: use tokio:task instead: https://stackoverflow.com/a/75840352
    // let t1 = thread::spawn(move || -> Result<(), rusqlite::Error> {
    //     let locked_db = db.lock().unwrap();
    //     let mut stmt = locked_db.prepare("select * from memo limit 1")?;
    //     let mut rows = stmt.query([])?;
    //     let _row = match rows.next() {
    //         Ok(it) => {
    //             println!("{:?}", it);
    //         }
    //         Err(_) => (),
    //     };

    //     println!("testing outsider variable {:?}", all_item);
    //     println!("testing outsider variable {:?}", outside_int);
    //     all_item.push("Mantab".to_string());

    //     //  let mut names = Vec::new();
    //     //  let Some(row) = rows.next()

    //     // ref: https://itsallaboutthebit.com/arc-mutex/
    //     // after locked_user goes out of scope, mutex will be unlocked again,
    //     // but you can also explicitly unlock it with:
    //     // drop(locked_user);
    //     Ok(())
    // });
    // let _ = t1.join().unwrap();
    // println!("testing modify variable {:?}", all_item); // Error!

    // ref: spawn vs spawn_blocking https://stackoverflow.com/a/74547875
    // we use spawn_blocking here because it related to IO files like sqlite db.
    let res = task::spawn_blocking(move || -> Result<Vec<String>, rusqlite::Error> {
        let mut all_item: Vec<String> = Vec::new();
        let locked_db = db.lock().unwrap();
        let mut stmt = locked_db.prepare("select * from memo limit 1")?;
        let mut rows = stmt.query([])?;
        let _row = match rows.next() {
            Ok(it) => {
                println!("{:?}", it);
            }
            Err(_) => (),
        };

        println!("testing outsider variable {:?}", outside_int);
        all_item.push("Mantab".to_string());

        //  let mut names = Vec::new();
        //  let Some(row) = rows.next()

        // after locked_user goes out of scope, mutex will be unlocked again,
        // but you can also explicitly unlock it with:
        // drop(locked_user);
        Ok(all_item)
    })
    .await
    .unwrap();

    let _ = match res {
        Ok(it) => {
            println!("testing modify variable {:?}", it);
            it;
        }
        Err(_) => {
            let empty_vec: Vec<String> = Vec::new();
            empty_vec;
        }
    };

    "Hello, World!"
}

async fn create_user(
    // this argument tells axum to parse the request body
    // as JSON into a `CreateUser` type
    Json(payload): Json<CreateUser>,
) -> (StatusCode, Json<User>) {
    // insert your application logic here
    let user = User {
        id: 1337,
        username: payload.username,
    };

    // this will be converted into a JSON response
    // with a status code of `201 Created`
    (StatusCode::CREATED, Json(user))
}

// the input to our `create_user` handler
#[derive(Deserialize)]
struct CreateUser {
    username: String,
}

// the output to our `create_user` handler
#[derive(Serialize)]
struct User {
    id: u64,
    username: String,
}

Maybe someone can just suggest me, or correct me.

Iteration 2

This is next iteration.

the sqlite db is come from use memos db. one of the best open source note app

use axum::{
    Json, Router,
    extract::State,
    http::StatusCode,
    routing::{get, post},
};
use rusqlite::Connection;
use serde::{Deserialize, Serialize};
use std::{
    sync::{Arc, Mutex},
    vec,
};
// use std::thread;
use tokio::task;

// Ref: how to use app state: https://users.rust-lang.org/t/how-to-pass-app-state-in-axum/104458/3

// define local module. the file at app_infra/mod.rs
mod app_infra;

#[derive(Debug, Clone)]
struct AppState {
    // Ref: how to make un-clonable object in external mod implementing Clone traits
    // here the link: https://itsallaboutthebit.com/arc-mutex/
    // Arc: will let the data / object shared between threads
    // Mutex: ensure only 1 thread at a time can access the data / object
    db: Arc<Mutex<Connection>>,
}

#[tokio::main]
async fn main() {
    // initialize tracing
    tracing_subscriber::fmt::init();

    let db = match app_infra::create_db_connection() {
        Ok(conn) => conn,
        Err(err) => panic!("error to connect to db {}", err.to_string()),
    };
    let cloneable_db = Arc::new(Mutex::new(db));

    let app_state = AppState { db: cloneable_db };

    // build our application with a route
    let app = Router::new()
        // `GET /` goes to `root`
        .route("/", get(root))
        .route("/memos", get(get_memo_list))
        .route("/basic-json", get(get_with_response_json))
        // `POST /users` goes to `create_user`
        .route("/users", post(create_user))
        .with_state(app_state);

    // run our app with hyper, listening globally on port 3000
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

// basic handler that responds with a static string
async fn root(State(AppState { db }): State<AppState>) -> &'static str {
    let outside_int = 213123i32;

    // let mut all_item: Vec<String> = Vec::new();
    // ref: use tokio:task instead: https://stackoverflow.com/a/75840352
    // ref: spawn vs spawn_blocking https://stackoverflow.com/a/74547875
    // we use spawn_blocking here because it related to IO files like sqlite db.
    let res = task::spawn_blocking(move || -> Result<Vec<String>, rusqlite::Error> {
        let mut all_item: Vec<String> = Vec::new();
        // ref: https://itsallaboutthebit.com/arc-mutex/
        // this is how to lock our mutex object
        let locked_db = db.lock().unwrap();
        let mut stmt = locked_db.prepare("select * from memo limit 1")?;
        let mut rows = stmt.query([])?;
        let _row = match rows.next() {
            Ok(it) => {
                println!("{:?}", it);
            }
            Err(_) => (),
        };

        println!("testing outsider variable {:?}", outside_int);
        all_item.push("Mantab".to_string());
        // after locked_user goes out of scope, mutex will be unlocked again,
        // but you can also explicitly unlock it with:
        // drop(locked_user);
        Ok(all_item)
    })
    .await
    .unwrap();

    let _ = match res {
        Ok(it) => {
            println!("testing modify variable {:?}", it);
            drop(it);
        }
        Err(_) => {
            let empty_vec: Vec<String> = Vec::new();
            drop(empty_vec);
        }
    };

    "Hello, World!"
}

async fn get_with_response_json() -> (StatusCode, Json<Vec<Memo>>) {
    let mut memo_list: Vec<Memo> = Vec::new();
    let mut tag_list: Vec<String> = Vec::new();
    tag_list.push("tag".to_string());

    let memo = Memo {
        id: 1,
        created_ts: 1,
        updated_ts: 1,
        content: "content".to_string(),
        payload: "".to_string(),
    };

    memo_list.push(memo);
    (StatusCode::OK, Json(memo_list))
}

async fn get_memo_list(State(AppState { db }): State<AppState>) -> (StatusCode, Json<Vec<Memo>>) {
    // let mut all_item: Vec<String> = Vec::new();
    // ref: use tokio:task instead: https://stackoverflow.com/a/75840352
    // ref: spawn vs spawn_blocking https://stackoverflow.com/a/74547875
    // we use spawn_blocking here because it related to IO files like sqlite db.
    let res = task::spawn_blocking(move || -> Result<Vec<Memo>, rusqlite::Error> {
        let mut all_item: Vec<Memo> = Vec::new();
        // ref: https://itsallaboutthebit.com/arc-mutex/
        // this is how to lock our mutex object
        let locked_db = db.lock().unwrap();
        let mut stmt = locked_db.prepare("select * from memo limit 1")?;
        let mut rows = stmt.query([])?;

        // copied form smt.query docs. just click it.
        while let Some(row) = rows.next()? {
            println!("{:?}", row);
            let memo_item = Memo {
                id: match row.get::<&str, i64>("id") {
                    Ok(it) => it,
                    Err(_) => 0i64,
                },
                created_ts: match row.get::<&str, i64>("created_ts") {
                    Ok(it) => it,
                    Err(_) => 0i64,
                },
                updated_ts: match row.get::<&str, i64>("updated_ts") {
                    Ok(it) => it,
                    Err(_) => 0i64,
                },
                content: match row.get::<&str, String>("content") {
                    Ok(it) => it,
                    Err(_) => "".to_string(),
                },
                payload: match row.get::<&str, String>("payload") {
                    Ok(it) => it,
                    Err(_) => "".to_string(),
                },
            };
            all_item.push(memo_item);
        }
        // after locked_user goes out of scope, mutex will be unlocked again,
        // but you can also explicitly unlock it with:
        // drop(locked_user);
        Ok(all_item)
    })
    .await
    .unwrap();

    match res {
        Ok(it) => {
            return (StatusCode::OK, Json(it));
        }
        Err(_) => {
            let memo_list: Vec<Memo> = Vec::new();
            return (StatusCode::INTERNAL_SERVER_ERROR, Json(memo_list));
        }
    };
}

async fn create_user(
    // this argument tells axum to parse the request body
    // as JSON into a `CreateUser` type
    Json(payload): Json<CreateUser>,
) -> (StatusCode, Json<User>) {
    // insert your application logic here
    let user = User {
        id: 1337,
        username: payload.username,
    };

    // this will be converted into a JSON response
    // with a status code of `201 Created`
    (StatusCode::CREATED, Json(user))
}

// the output to our `memo`
#[derive(Debug, Serialize)]
struct Memo {
    id: i64,
    created_ts: i64,
    updated_ts: i64,
    content: String,
    payload: String,
}

// the input to our `create_user` handler
#[derive(Deserialize)]
struct CreateUser {
    username: String,
}

// the output to our `create_user` handler
#[derive(Serialize)]
struct User {
    id: u64,
    username: String,
}

I forget to put Cargo.toml. here the Cargo.toml

[package]
name = "bosnotes"
version = "0.1.0"
edition = "2024"

[dependencies]
time = "0.3.44"
# `bundled` causes us to automatically compile and link in an up to date
# version of SQLite for you. This avoids many common build issues, and
# avoids depending on the version of SQLite on the users system (or your
# system), which may be old or missing. It's the right choice for most
# programs that control their own SQLite databases.
#
# That said, it's not ideal for all scenarios and in particular, generic
# libraries built around `rusqlite` should probably not enable it, which
# is why it is not a default feature -- it could become hard to disable.
rusqlite = { version = "0.38.0", features = ["bundled"] }
axum = { version = "0.8.8" }
# ref: https://stackoverflow.com/a/79605363
tokio = { version = "1.49.0", features = ["full"] }
# ref: https://users.rust-lang.org/t/serde-cannot-find-derive-macro-deserialize-serialize-in-this-scope/79402
serde = { version = "1.0.228", features = ["std", "derive", "serde_derive"] }
tracing-subscriber = "0.3.22"
tower = "0.5.2"


[dependencies.uuid]
version = "1.19.0"
# Lets you generate random UUIDs
features = [
    "v4",
]

and when I try to find how much the resource usages, here the result on idle state:

How do I setup templating in Golang Project

Naufal Rabbani — Tue, 23 Sep 2025 17:20:21 +0000

Use xtemplate for nested templating

Here the example when I use xtemplate alongside with go-fiber.

Why I use xtemplate if go-fiber already created official html templating with nested feature? This pattern is currently what I'm familiar with. So, for now, I have no issue to keep using it.

But this might not comply with your project needs.

package helpers

import (
    "github.com/dannyvankooten/extemplate"
    "github.com/gofiber/fiber/v2"
)

// Init
var xt = extemplate.New()

// we only need call this once.
func ParseTemplateWithinDir(viewDir string) error {
    return xt.ParseDir(viewDir, []string{".html"})
}

// Render the targeted template
func RenderTemplateWithContext(c *fiber.Ctx, viewDir, name string, data map[string]interface{}) error {

        // In development phase, I want to make it re-parsing the template every time my app render the pages.
        // this is Opt-in. And we can disabled it in production env.
    err := ParseTemplateWithinDir(viewDir)
    if err != nil {
        return err
    }

        // Execute the template.
    return xt.ExecuteTemplate(c.Response().BodyWriter(), name, data)
}

// helper to ensure the response is HTML
func UseHtml(c *fiber.Ctx) {
    c.Response().Header.Add("Content-Type", "text/html; charset=utf-8")
}

Create the templates

File views/base.html

<!-- file: views/base.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Testing Unpolly</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/unpoly@3.11.0/unpoly.min.css">
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/unpoly@3.11.0/unpoly-bootstrap5.min.css">
</head>
<body>
    {{block "content" .}}From Parent{{end}}
    <h1>Another Content!</h1>

    <script src="https://cdn.jsdelivr.net/npm/unpoly@3.11.0/unpoly.min.js"></script>
    <script
            src="https://code.jquery.com/jquery-3.7.1.min.js"
            integrity="sha256-/JqT3SQfawRcv/BIHPThkBvs0OEvtFFmqPF/lYI/Cxo="
            crossorigin="anonymous"></script>
</body>
</html>

File views/home.html

{{extends "base.html"}}
{{define "content" -}}
<!-- file: views/home.html -->
<h1>From Home template (children)</h1>
{{end}}

Render the Template

Last, render the template.

// handler.go

var viewDir, _ = filepath.Abs("./modules/chat/views/")
ctrl := &SomeCtrl{
  viewDir: viewDir,
}

// ...
app.Get("/app/", func(ctx *fiber.Ctx) error {
    helpers.UseHtml(ctx)
    err := helpers.RenderTemplateWithContext(ctx, ctrl.viewDir, "home.html", map[string]interface{}{
        "someData": "someData to render",
    })
    if err != nil {
        log.Error(err)
    }
    return nil
})
// ...