How to pass object between modules properly?

Question

I'm learning Rust, and I have problem with understanding passing objects by reference and lifetimes. I decided to create a simple REST (Axum + HashMap as database). I got a problem, because I do not know how to properly set database instance to save and retrieve from.

I have database.rs file:

pub struct Database<'a> {
    pub players: HashMap<u32, &'a Player>
}

impl<'a>  Database<'a>   {
    pub fn save_to_db(&mut self, player: &'a Player) -> () {
        self.players.insert(player.id, player);
    }

}

File routes.rs which get JSON passed from user:

pub struct Routes<'a> {
    pub(crate) database: Database<'a>
}

impl<'a> Routes<'a> {
    pub async fn create_player(&mut self, Json(payload): Json<CreatePlayer>) -> impl IntoResponse {
        let player = Player {
            id: 1,
            name: payload.name,
            age: payload.age,
            position: payload.position,
        };

        self.database.save_to_db(&player);

        (StatusCode::OK, Json(player))
    }

    pub async fn get_player(Path(_): Path<String>) -> impl IntoResponse {
        let player = Player {
            id: 1,
            name: String::from("Some Player"),
            age: 28,
            position: String::from("midfielder"),
        };

        (StatusCode::OK, Json(player))
    }
}

and main.rs to run it all:

mod http;
use crate::http::routes::Routes;

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

    let routes = Routes {
        database: Database {
            players: HashMap::new()
        }
    };

    let router = Router::new()
        .route("/player/:id", get(routes.get_player()))
        .route("/player", post(routes.create_player));


    axum::Server::bind(&"0.0.0.0:8080".parse().unwrap())
        .serve(router.into_make_service())
        .await
        .unwrap();
}

The problem is with these lines:

 .route("/player/:id", get(routes.get_player()))
 .route("/player", post(routes.create_player));

It is impossible in Axum to pass my database object here. I tried also to move this:

let routes = Routes {
    database: Database {
        players: HashMap::new()
    }
};

into routes.rs file but the problem would be same - could not pass self into get_player and create_player methods.

How should I create an instance of my HashMap database and how to pass it correctly through the whole application?

Answer 1

Sorry this may not be entirely an answer but it's easier than the back and forth in the comments.

You can't actually use a struct field as a hashmap key when the struct is the value as this would make the hashmap itself a self-referential struct, an undertaking fraught with peril. You can always just copy the key, it's only a 32-bit integer:

use std::collections::HashMap;

#[derive(Debug)]
struct Player {
    id: i32,
    name: String,
    position: String,
}

struct Database {
    players: HashMap<i32, Player>
}

impl Database {
    pub fn add_player(&mut self, p: Player) -> () {
        let pid = p.id.clone();
        self.players.insert(pid, p);
    }
    
    pub fn get_player(&self, id: &i32) -> Option<&Player> {
        self.players.get(id)
    }
}

fn main() -> () {
    let p = Player {
        id: 0,
        name: String::from("Tom Brady"),
        position: String::from("Quarterback"),
    };
    
    let mut db = Database {
        players: HashMap::new()
    };
    
    db.add_player(p);
    let retrieved = db.get_player(&0);
    println!("{:?}", retrieved);
}

Playground

As for Player vs &Player as the hashmap value type, if you are constructing the player struct in a route handler function, the memory for that player is deallocated as soon as the function returns and the player is out of scope. So you can't store a borrowed reference in a data structure: you'd essentially have a dangling pointer to freed memory (same reason the struct fields are String and not &str). You want to transfer ownership of the player to the hashmap.