.env.example

@@ -1,2 +1 @@
-MONGODB_URI=mongodb://localhost:27017
+DATABASE_URL="sqlite:rick_and_morty.db"
-DB_NAME=rick_and_morty

.gitignore

@@ -1,2 +1,3 @@
 /target
 .env
+*.db

Cargo.toml

@@ -7,14 +7,18 @@ edition = "2024"
 anyhow = "1.0.98"
 axum = { version = "0.8.4", features = ["macros"] }
 dotenvy = "0.15.7"
-futures-util = "0.3.31"
 http = "1.3.1"
-mongodb = "3.2.4"
-once_cell = "1.21.3"
 reqwest = { version = "0.12.22", features = ["json"] }
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
-tokio = { version = "1.46.1", features = [] }
+sqlx = { version = "0.8.6", features = [
+    "sqlite",
+    "runtime-tokio",
+    "tls-native-tls",
+    "macros",
+    "uuid",
+] }
+tokio = { version = "1.46.1", features = ["full"] }
 tower = { version = "0.5.2", features = ["util"] }
 tower-http = { version = "0.6.6", features = ["cors", "fs", "trace"] }
 tracing = "0.1.41"

Dockerfile

@@ -10,15 +10,20 @@ WORKDIR /app
 RUN apt-get update && \
     apt-get install -y pkg-config libssl-dev build-essential ca-certificates
 
+COPY migrations/ migrations/
 COPY src/ src/
 COPY Cargo.toml Cargo.lock ./
 RUN cargo build --release
 
 FROM debian:bookworm-slim
 WORKDIR /app
-RUN apt-get update && apt-get install -y ca-certificates openssl && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y ca-certificates openssl sqlite3 && rm -rf /var/lib/apt/lists/*
+RUN mkdir -p /app/data
 COPY --from=backend-builder /app/target/release/rick-and-morty .
+COPY --from=backend-builder /app/migrations ./migrations
 COPY --from=frontend-builder /app/dist ./frontend/dist
 EXPOSE 8000
 
-CMD ["./rick-and-morty"]
+COPY entrypoint.sh /app/
+RUN chmod +x /app/entrypoint.sh
+ENTRYPOINT ["/app/entrypoint.sh"]

compose.yml

@@ -1,26 +1,15 @@
 services:
-  mongo:
-    image: mongo:6.0
-    container_name: rick_and_morty_mongo
-    restart: unless-stopped
-    ports:
-      - "27017:27017"
-    environment:
-      MONGO_INITDB_DATABASE: rick_and_morty
-    volumes:
-      - mongo-data:/data/db
   app:
     build: .
     container_name: rick_and_morty_app
-    depends_on:
-      - mongo
     environment:
-      MONGODB_URI: mongodb://mongo:27017
+      DATABASE_URL: "sqlite:///app/data/rick_and_morty.db"
-      DB_NAME: rick_and_morty
       BIND_ADDR: 0.0.0.0:8000
     ports:
       - "8000:8000"
     restart: unless-stopped
+    volumes:
+      - rick_and_morty_data:/app/data
 
 volumes:
-  mongo-data:
+  rick_and_morty_data:

entrypoint.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+chown -R $(id -u):$(id -g) /app/data
+exec ./rick-and-morty

migrations/001_init.sql

@@ -0,0 +1,18 @@
+CREATE TABLE characters (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    rmid INTEGER NOT NULL,
+    name TEXT NOT NULL,
+    status TEXT NOT NULL,
+    species TEXT NOT NULL,
+    type TEXT NOT NULL,
+    gender TEXT NOT NULL,
+    origin_name TEXT NOT NULL,
+    origin_url TEXT NOT NULL,
+    location_name TEXT NOT NULL,
+    location_url TEXT NOT NULL,
+    image TEXT NOT NULL,
+    episode TEXT NOT NULL, -- store as comma-separated or JSON
+    url TEXT NOT NULL,
+    created TEXT NOT NULL,
+    elo_rating REAL NOT NULL
+);

src/bin/fetch_characters.rs

@@ -1,11 +1,7 @@
-use mongodb::{
-    Client,
-    bson::{doc, to_document},
-    options::UpdateOptions,
-};
 use reqwest::Client as HttpClient;
 use rick_and_morty::models::{Character, OriginOrLocation};
 use serde::{Deserialize, Serialize};
+use sqlx::{Row, SqlitePool};
 
 #[derive(Debug, Deserialize, Serialize)]
 struct ApiCharacter {
@@ -27,17 +23,20 @@ struct ApiCharacter {
 impl From<ApiCharacter> for Character {
     fn from(api: ApiCharacter) -> Self {
         Character {
-            id: None, // always None for new/incoming data
+            id: 0, // Ignored for new/incoming data; SQLite autoincrements
             rmid: api.id,
             name: api.name,
             status: api.status,
             species: api.species,
             r#type: api.character_type,
             gender: api.gender,
-            origin: api.origin,
+            origin_name: api.origin.name,
-            location: api.location,
+            origin_url: api.origin.url,
+            location_name: api.location.name,
+            location_url: api.location.url,
             image: api.image,
-            episode: api.episode,
+            // Store as JSON string
+            episode: serde_json::to_string(&api.episode).unwrap(),
             url: api.url,
             created: api.created,
             elo_rating: 1000.0,
@@ -58,13 +57,9 @@ fn init_tracing() {
 async fn main() -> anyhow::Result<()> {
     init_tracing();
     dotenvy::dotenv().ok();
-    let db_uri =
-        std::env::var("MONGODB_URI").unwrap_or_else(|_| "mongodb://localhost:27017".to_string());
-    let db_name = std::env::var("DB_NAME").unwrap_or_else(|_| "rick_and_morty".to_string());
 
-    let client = Client::with_uri_str(&db_uri).await?;
+    let db_url = std::env::var("DATABASE_URL").expect("DATABASE_URL not set");
-    let db = client.database(&db_name);
+    let pool = SqlitePool::connect(&db_url).await?;
-    let collection = db.collection::<Character>("characters");
 
     tracing::info!("Starting to fetch characters from Rick and Morty API");
     let http = HttpClient::new();
@@ -92,30 +87,77 @@ async fn main() -> anyhow::Result<()> {
         count = all_characters.len(),
         "Fetched all characters, starting DB upsert"
     );
-    let options = UpdateOptions::builder().upsert(true).build();
-    // let insert_result = collection.insert_many(all_characters.clone()).await?;
 
     for character in &all_characters {
-        let filter = doc! { "rmid": character.rmid };
+        // Try to fetch existing character by rmid
-        let mut set_doc = to_document(character)?;
+        let row = sqlx::query("SELECT id, elo_rating FROM characters WHERE rmid = ?")
-        set_doc.remove("elo_rating"); // Do NOT overwrite existing Elo
+            .bind(character.rmid)
-        let update = doc! {
+            .fetch_optional(&pool)
-            "$set": set_doc,
+            .await?;
-            "$setOnInsert": { "elo_rating": 1000.0 }
+
-        };
+        if let Some(row) = row {
-        if let Err(e) = collection
+            // Exists: update all fields except elo_rating
-            .update_one(filter, update)
+            let id: i64 = row.get("id");
-            .with_options(Some(options.clone()))
+            sqlx::query(
-            .await
+                "UPDATE characters SET
-        {
+                    name = ?, status = ?, species = ?, type = ?, gender = ?,
-            tracing::error!(error = ?e, id = character.rmid, name = %character.name, "Failed to upsert character");
+                    origin_name = ?, origin_url = ?,
+                    location_name = ?, location_url = ?,
+                    image = ?, episode = ?, url = ?, created = ?
+                WHERE id = ?",
+            )
+            .bind(&character.name)
+            .bind(&character.status)
+            .bind(&character.species)
+            .bind(&character.r#type)
+            .bind(&character.gender)
+            .bind(&character.origin_name)
+            .bind(&character.origin_url)
+            .bind(&character.location_name)
+            .bind(&character.location_url)
+            .bind(&character.image)
+            .bind(&character.episode)
+            .bind(&character.url)
+            .bind(&character.created)
+            .bind(id)
+            .execute(&pool)
+            .await?;
+            tracing::info!(id = character.rmid, name = %character.name, "Updated character (no elo overwrite)");
+        } else {
+            // Insert new character with default elo_rating
+            sqlx::query(
+                "INSERT INTO characters (
+                    rmid, name, status, species, type, gender,
+                    origin_name, origin_url, location_name, location_url,
+                    image, episode, url, created, elo_rating
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            )
+            .bind(character.rmid)
+            .bind(&character.name)
+            .bind(&character.status)
+            .bind(&character.species)
+            .bind(&character.r#type)
+            .bind(&character.gender)
+            .bind(&character.origin_name)
+            .bind(&character.origin_url)
+            .bind(&character.location_name)
+            .bind(&character.location_url)
+            .bind(&character.image)
+            .bind(&character.episode)
+            .bind(&character.url)
+            .bind(&character.created)
+            .bind(1000.0)
+            .execute(&pool)
+            .await?;
+            tracing::info!(id = character.rmid, name = %character.name, "Inserted new character");
         }
-        tracing::info!(id = character.rmid, name = %character.name, "Upserted character");
     }
 
     // tracing::info!("Inserted {} characters", insert_result.inserted_ids.len());
 
-    let character_count = collection.count_documents(doc! {}).await?;
+    let character_count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM characters")
+        .fetch_one(&pool)
+        .await?;
     tracing::info!(
         count = character_count,
         "Total characters in DB after import"

src/db.rs

@@ -1,11 +1,6 @@
-use mongodb::{Client, Database};
+use sqlx::sqlite::SqlitePool;
-use once_cell::sync::OnceCell;
 
-pub static DB: OnceCell<Database> = OnceCell::new();
+pub async fn connect_db(db_url: &str) -> Result<SqlitePool, sqlx::Error> {
-
+    let pool = SqlitePool::connect(db_url).await?;
-pub async fn connect_db(uri: &str, db_name: &str) -> mongodb::error::Result<()> {
+    Ok(pool)
-    let client = Client::with_uri_str(uri).await?;
-    let db = client.database(db_name);
-    DB.set(db).ok();
-    Ok(())
 }

src/main.rs

@@ -20,19 +20,17 @@ fn init_tracing() {
 }
 
 #[tokio::main]
-async fn main() {
+async fn main() -> anyhow::Result<()> {
     init_tracing();
     dotenvy::dotenv().ok();
 
-    let db_uri = std::env::var("MONGODB_URI").expect("MONGODB_URI not set");
-    let db_name = std::env::var("DB_NAME").unwrap_or_else(|_| "rick_and_morty".to_string());
     let address = std::env::var("BIND_ADDR").unwrap_or_else(|_| "0.0.0.0:8000".to_string());
+    let db_url = std::env::var("DATABASE_URL").expect("DATABASE_URL not set");
 
-    db::connect_db(&db_uri, &db_name)
+    let db = db::connect_db(&db_url).await?;
-        .await
-        .expect("Failed to connect to database");
 
-    let db = db::DB.get().expect("Database not initialized");
+    // migrations
+    sqlx::migrate!().run(&db).await?;
 
     let cors = CorsLayer::new()
         // allow `GET` and `POST` when accessing the resource
@@ -44,7 +42,7 @@ async fn main() {
     let app = Router::new()
         .route("/characters", get(routes::get_characters))
         .route("/rate", post(routes::rate))
-        .with_state(db.clone())
+        .with_state(db)
         .layer(TraceLayer::new_for_http())
         .layer(cors)
         .fallback_service(ServeDir::new("frontend/dist").append_index_html_on_directories(true));
@@ -55,5 +53,9 @@ async fn main() {
 
     println!("Listening on {}", listener.local_addr().unwrap());
 
-    axum::serve(listener, app).await.unwrap();
+    axum::serve(listener, app).await?;
+
+    tracing::info!("Server started successfully");
+
+    Ok(())
 }

src/models/mod.rs

@@ -1,26 +1,27 @@
-use mongodb::bson::{doc, oid::ObjectId};
 use serde::{Deserialize, Serialize};
+use sqlx::prelude::FromRow;
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, FromRow)]
 pub struct OriginOrLocation {
     pub name: String,
     pub url: String,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, FromRow)]
 pub struct Character {
-    #[serde(rename = "_id", skip_serializing_if = "Option::is_none")]
+    pub id: i64,
-    pub id: Option<ObjectId>, // Mongo _id
     pub rmid: i32, // Rick&Morty ID, don't confuse with _id
     pub name: String,
     pub status: String,
     pub species: String,
     pub r#type: String,
     pub gender: String,
-    pub origin: OriginOrLocation,
+    pub origin_name: String,
-    pub location: OriginOrLocation,
+    pub origin_url: String,
+    pub location_name: String,
+    pub location_url: String,
     pub image: String,
-    pub episode: Vec<String>,
+    pub episode: String,
     pub url: String,
     pub created: String,
     pub elo_rating: f64,

src/routes/mod.rs

@@ -1,10 +1,7 @@
 use axum::response::Html;
 use axum::{Json, extract::State, http::StatusCode};
-use futures_util::stream::TryStreamExt;
-use mongodb::Database;
-use mongodb::bson::doc;
-use mongodb::bson::oid::ObjectId;
 use serde::{Deserialize, Serialize};
+use sqlx::{Sqlite, SqlitePool, Transaction};
 
 use crate::models::Character;
 use crate::utils::calculate_elo;
@@ -15,7 +12,7 @@ pub struct RateRequest {
     loser_id: String,
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Serialize)]
 pub struct RateResponse {
     winner: Character,
     loser: Character,
@@ -24,94 +21,74 @@ pub struct RateResponse {
 static K_FACTOR: f64 = 32.0; // K-factor for Elo rating system
 
 pub async fn get_characters(
-    State(db): State<Database>,
+    State(db): State<SqlitePool>,
 ) -> Result<Json<Vec<Character>>, StatusCode> {
-    let collection = db.collection::<Character>("characters");
+    let characters =
-    let pipeline = vec![doc! { "$sort": { "elo_rating": -1 } }];
+        sqlx::query_as::<_, Character>("SELECT * FROM characters ORDER BY elo_rating DESC")
-
+            .fetch_all(&db)
-    let mut cursor = collection
+            .await
-        .aggregate(pipeline)
+            .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
-        .await
-        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
-
-    let mut characters = Vec::new();
-    while let Some(result) = cursor
-        .try_next()
-        .await
-        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
-    {
-        let character: Character =
-            mongodb::bson::from_document(result).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
-        characters.push(character);
-    }
-
-    tracing::info!(count = characters.len(), "Fetched characters from DB");
 
     Ok(Json(characters))
 }
 
 #[axum::debug_handler]
 pub async fn rate(
-    State(db): State<Database>,
+    State(db): State<SqlitePool>,
     Json(req): Json<RateRequest>,
 ) -> Result<Json<RateResponse>, StatusCode> {
-    let collection = db.collection::<Character>("characters");
+    // 1. Fetch characters by ID
-
+    let winner: Character = sqlx::query_as("SELECT * FROM characters WHERE id = ?")
-    let winner_oid = ObjectId::parse_str(&req.winner_id).map_err(|_| StatusCode::BAD_REQUEST)?;
+        .bind(&req.winner_id)
-    let loser_oid = ObjectId::parse_str(&req.loser_id).map_err(|_| StatusCode::BAD_REQUEST)?;
+        .fetch_optional(&db)
-
-    let winner = collection
-        .find_one(doc! { "_id": winner_oid })
         .await
-        .ok()
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
-        .flatten()
         .ok_or(StatusCode::NOT_FOUND)?;
-    let loser = collection
+
-        .find_one(doc! { "_id": loser_oid })
+    let loser: Character = sqlx::query_as("SELECT * FROM characters WHERE id = ?")
+        .bind(&req.loser_id)
+        .fetch_optional(&db)
         .await
-        .ok()
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
-        .flatten()
         .ok_or(StatusCode::NOT_FOUND)?;
 
     let (new_winner_elo, new_loser_elo) =
         calculate_elo(winner.elo_rating, loser.elo_rating, K_FACTOR);
 
-    collection
+    let mut tx: Transaction<'_, Sqlite> = db
-        .update_one(
+        .begin()
-            doc! {"_id": &winner_oid},
-            doc! { "$set": { "elo_rating": new_winner_elo } },
-        )
         .await
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
-    collection
+    sqlx::query("UPDATE characters SET elo_rating = ? WHERE id = ?")
-        .update_one(
+        .bind(new_winner_elo)
-            doc! {"_id": &loser_oid},
+        .bind(&req.winner_id)
-            doc! { "$set": { "elo_rating": new_loser_elo } },
+        .execute(&mut *tx)
-        )
         .await
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
-    // return resposnse with characters' new Elo ratings
+    sqlx::query("UPDATE characters SET elo_rating = ? WHERE id = ?")
-    let updated_winner = collection
+        .bind(new_loser_elo)
-        .find_one(doc! { "_id": winner_oid })
+        .bind(&req.loser_id)
+        .execute(&mut *tx)
         .await
-        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
-        .ok_or(StatusCode::NOT_FOUND)?;
-    let updated_loser = collection
-        .find_one(doc! { "_id": loser_oid })
-        .await
-        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
-        .ok_or(StatusCode::NOT_FOUND)?;
 
-    tracing::info!(
+    tx.commit()
-        "Rated characters: winner_id = {}, loser_id = {}, new_winner_elo =
+        .await
-    {}, new_loser_elo = {}",
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
-        req.winner_id,
+
-        req.loser_id,
+    let updated_winner: Character = sqlx::query_as("SELECT * FROM characters WHERE id = ?")
-        new_winner_elo,
+        .bind(&req.winner_id)
-        new_loser_elo
+        .fetch_one(&db)
-    );
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+
+    let updated_loser: Character = sqlx::query_as("SELECT * FROM characters WHERE id = ?")
+        .bind(&req.loser_id)
+        .fetch_one(&db)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
     Ok(Json(RateResponse {
         winner: updated_winner,