Skip to content
TheChatArchiveThe Chat Archive
grok-3-preview-02-24· xAIHugging Face LMArena Human Preference 140K

Give me an example of a full stack svelte rust arcadeDB app by making a call on the FE…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with chatgpt-4o-latest-20250326’s answer.
  1. User

    Give me an example of a full stack svelte rust arcadeDB app by making a call on the FE and flowing all the way through to the database and back.

    Utilize best practices and architect your response in a way that is meant to teach the reader how the flow of communication works.

  2. Assistant

    Let's create a comprehensive example of a full-stack Svelte + Rust + ArcadeDB application. We'll build a simple "High Score" system for an arcade game, showing the complete flow from frontend to database and back. I'll break this down into clear sections and explain each part.

    Application Overview

    • Frontend (FE): Svelte - Handles UI and makes API calls
    • Backend (BE): Rust (Actix-web) - Handles API endpoints and business logic
    • Database: ArcadeDB - Stores high scores
    • Flow: User submits a score → FE calls BE → BE stores in ArcadeDB → BE returns result → FE displays success/error

    Project Structure

    Here's how we'll organize our project:

    highscore-app/
    ├── frontend/               # Svelte frontend
    │   ├── src/
    │   │   ├── App.svelte
    │   │   ├── main.js
    │   │   └── lib/api.js
    │   ├── package.json
    │   └── ...
    ├── backend/               # Rust backend
    │   ├── src/
    │   │   ├── main.rs
    │   │   ├── models.rs
    │   │   └── db.rs
    │   ├── Cargo.toml
    │   └── ...
    ├── docker-compose.yml     # For running ArcadeDB
    └── README.md
    

    Step 1: Setting Up ArcadeDB

    ArcadeDB is a multi-model database that supports graph, document, key-value, and time-series data models. We'll use it as a document database to store high scores.

    docker-compose.yml

    We'll use Docker to run ArcadeDB locally.

    version: '3.8'
    services:
      arcadedb:
        image: arcadedata/arcadedb:latest
        ports:
          - "2480:2480"  # HTTP API
          - "2424:2424"  # Binary protocol
        environment:
          - JAVA_OPTS=-Darcadedb.server.rootPassword=playwithdata
        volumes:
          - arcadedb_data:/arcadedb/databases
    
    volumes:
      arcadedb_data:
    

    Run ArcadeDB:

    docker-compose up -d
    

    ArcadeDB will be accessible at http://localhost:2480. You can use the web interface to create a database named HighScoresDB and a collection (or "bucket") named HighScores.


    Step 2: Backend (Rust with Actix-web)

    The backend will expose an API endpoint to submit high scores and retrieve the top 10 scores. We'll use the arcadedb-rs crate (a hypothetical Rust client for ArcadeDB; if it doesn't exist, you might need to use HTTP requests to ArcadeDB's REST API).

    backend/Cargo.toml

    [package]
    name = "highscore-backend"
    version = "0.1.0"
    edition = "2021"
    
    [dependencies]
    actix-web = "4.3"
    serde = { version = "1.0", features = ["derive"] }
    serde_json = "1.0"
    reqwest = { version = "0.11", features = ["json"] }  # For HTTP requests to ArcadeDB
    tokio = { version = "1.0", features = ["full"] }
    

    backend/src/models.rs

    Define the data model for a high score.

    use serde::{Deserialize, Serialize};
    
    #[derive(Serialize, Deserialize, Debug)]
    pub struct HighScore {
        pub player_name: String,
        pub score: i32,
        pub timestamp: i64, // Unix timestamp
    }
    

    backend/src/db.rs

    Handle database interactions with ArcadeDB. Since ArcadeDB supports a REST API, we'll use reqwest to make HTTP calls.

    use crate::models::HighScore;
    use reqwest::Client;
    use serde_json::json;
    
    pub struct ArcadeDBClient {
        client: Client,
        base_url: String,
        database: String,
    }
    
    impl ArcadeDBClient {
        pub fn new(base_url: &str, database: &str) -> Self {
            ArcadeDBClient {
                client: Client::new(),
                base_url: base_url.to_string(),
                database: database.to_string(),
            }
        }
    
        pub async fn insert_high_score(&self, high_score: &HighScore) -> Result<String, reqwest::Error> {
            let url = format!("{}/api/v1/document/{}", self.base_url, self.database);
            let body = json!({
                "@type": "HighScores",
                "player_name": high_score.player_name,
                "score": high_score.score,
                "timestamp": high_score.timestamp
            });
    
            let response = self.client
                .post(&url)
                .header("Content-Type", "application/json")
                .body(body.to_string())
                .send()
                .await?;
    
            let result: serde_json::Value = response.json().await?;
            Ok(result["result"]["@rid"].as_str().unwrap_or("").to_string())
        }
    
        pub async fn get_top_scores(&self, limit: i32) -> Result<Vec<HighScore>, reqwest::Error> {
            let url = format!("{}/api/v1/query/{}", self.base_url, self.database);
            let query = json!({
                "command": "SELECT FROM HighScores ORDER BY score DESC LIMIT :limit",
                "parameters": { "limit": limit }
            });
    
            let response = self.client
                .post(&url)
                .header("Content-Type", "application/json")
                .body(query.to_string())
                .send()
                .await?;
    
            let result: serde_json::Value = response.json().await?;
            let scores: Vec<HighScore> = serde_json::from_value(result["result"].clone()).unwrap_or_default();
            Ok(scores)
        }
    }
    

    backend/src/main.rs

    Set up the Actix-web server and API endpoints.

    use actix_web::{web, App, HttpResponse, HttpServer, Responder};
    use serde::Deserialize;
    use std::time::{SystemTime, UNIX_EPOCH};
    
    mod db;
    mod models;
    
    use db::ArcadeDBClient;
    use models::HighScore;
    
    #[derive(Deserialize)]
    struct SubmitScoreRequest {
        player_name: String,
        score: i32,
    }
    
    async fn submit_score(
        req: web::Json<SubmitScoreRequest>,
        db_client: web::Data<ArcadeDBClient>,
    ) -> impl Responder {
        let timestamp = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_secs() as i64;
    
        let high_score = HighScore {
            player_name: req.player_name.clone(),
            score: req.score,
            timestamp,
        };
    
        match db_client.insert_high_score(&high_score).await {
            Ok(rid) => HttpResponse::Ok().json(json!({ "status": "success", "record_id": rid })),
            Err(e) => HttpResponse::InternalServerError().json(json!({ "status": "error", "message": e.to_string() })),
        }
    }
    
    async fn get_top_scores(db_client: web::Data<ArcadeDBClient>) -> impl Responder {
        match db_client.get_top_scores(10).await {
            Ok(scores) => HttpResponse::Ok().json(scores),
            Err(e) => HttpResponse::InternalServerError().json(json!({ "status": "error", "message": e.to_string() })),
        }
    }
    
    #[actix_web::main]
    async fn main() -> std::io::Result<()> {
        let db_client = ArcadeDBClient::new("http://localhost:2480", "HighScoresDB");
        let db_client_data = web::Data::new(db_client);
    
        HttpServer::new(move || {
            App::new()
                .app_data(db_client_data.clone())
                .route("/api/submit_score", web::post().to(submit_score))
                .route("/api/top_scores", web::get().to(get_top_scores))
        })
        .bind("127.0.0.1:8080")?
        .run()
        .await
    }
    

    Running the Backend

    Run the backend with:

    cd backend
    cargo run
    

    The backend will expose two endpoints:

    • POST /api/submit_score - Submit a new high score
    • GET /api/top_scores - Retrieve the top 10 scores

    Step 3: Frontend (Svelte)

    The frontend will allow users to submit scores and view the leaderboard. We'll use Svelte for its simplicity and reactivity.

    frontend/package.json

    {
      "name": "highscore-frontend",
      "version": "0.1.0",
      "private": true,
      "scripts": {
        "dev": "vite",
        "build": "vite build",
        "serve": "vite preview"
      },
      "devDependencies": {
        "@sveltejs/vite-plugin-svelte": "^1.0.0",
        "svelte": "^3.49.0",
        "vite": "^3.0.0"
      }
    }
    

    frontend/src/lib/api.js

    Create a utility to make API calls to the backend.

    const API_BASE_URL = 'http://localhost:8080/api';
    
    export async function submitScore(playerName, score) {
      const response = await fetch(`${API_BASE_URL}/submit_score`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ player_name: playerName, score }),
      });
      return response.json();
    }
    
    export async function getTopScores() {
      const response = await fetch(`${API_BASE_URL}/top_scores`);
      return response.json();
    }
    

    frontend/src/App.svelte

    Create the main Svelte component to handle user interaction.

    <script>
      import { onMount } from 'svelte';
      import { submitScore, getTopScores } from './lib/api';
    
      let playerName = '';
      let score = '';
      let topScores = [];
      let message = '';
    
      onMount(async () => {
        await fetchTopScores();
      });
    
      async function handleSubmit() {
        if (!playerName || !score) {
          message = 'Please enter both player name and score.';
          return;
        }
    
        const result = await submitScore(playerName, parseInt(score));
        if (result.status === 'success') {
          message = 'Score submitted successfully!';
          playerName = '';
          score = '';
          await fetchTopScores();
        } else {
          message = `Error: ${result.message}`;
        }
      }
    
      async function fetchTopScores() {
        topScores = await getTopScores();
      }
    </script>
    
    <main>
      <h1>High Score Arcade</h1>
    
      <section>
        <h2>Submit Your Score</h2>
        <form on:submit|preventDefault={handleSubmit}>
          <label>
            Player Name:
            <input type="text" bind:value={playerName} />
          </label>
          <label>
            Score:
            <input type="number" bind:value={score} />
          </label>
          <button type="submit">Submit</button>
        </form>
        {#if message}
          <p>{message}</p>
        {/if}
      </section>
    
      <section>
        <h2>Leaderboard</h2>
        <table>
          <thead>
            <tr>
              <th>Rank</th>
              <th>Player</th>
              <th>Score</th>
              <th>Date</th>
            </tr>
          </thead>
          <tbody>
            {#each topScores as score, index}
              <tr>
                <td>{index + 1}</td>
                <td>{score.player_name}</td>
                <td>{score.score}</td>
                <td>{new Date(score.timestamp * 1000).toLocaleString()}</td>
              </tr>
            {/each}
          </tbody>
        </table>
      </section>
    </main>
    
    <style>
      main {
        max-width: 800px;
        margin: 0 auto;
        padding: 20px;
      }
      form {
        display: flex;
        flex-direction: column;
        gap: 10px;
        margin-bottom: 20px;
      }
      table {
        width: 100%;
        border-collapse: collapse;
      }
      th, td {
        border: 1px solid #ddd;
        padding: 8px;
        text-align: left;
      }
      th {
        background-color: #f2f2f2;
      }
    </style>
    

    frontend/src/main.js

    Set up the Svelte app.

    import App from './App.svelte';
    
    const app = new App({
      target: document.body,
    });
    
    export default app;
    

    Running the Frontend

    Run the frontend with:

    cd frontend
    npm install
    npm run dev
    

    The frontend will be accessible at http://localhost:5173.


    Step 4: Understanding the Flow

    Let's walk through the flow of a user submitting a score, showing how data moves through the stack.

    1. User Interaction (Frontend)

    • The user enters their name (playerName) and score (score) in the form in App.svelte.
    • When the user clicks "Submit," the handleSubmit function is called.
    • handleSubmit calls submitScore from api.js, which makes a POST request to http://localhost:8080/api/submit_score with the payload { player_name, score }.

    2. Backend API (Rust)

    • The Actix-web server receives the POST /api/submit_score request.
    • The submit_score handler is invoked, deserializing the JSON payload into a SubmitScoreRequest.
    • A HighScore struct is created, adding a timestamp.
    • The ArcadeDBClient is used to call insert_high_score, which makes a POST request to ArcadeDB's REST API at http://localhost:2480/api/v1/document/HighScoresDB.

    3. Database (ArcadeDB)

    • ArcadeDB receives the POST request and stores the high score as a document in the HighScores bucket.
    • ArcadeDB returns a response with the record ID (@rid) of the newly created document.
    • The ArcadeDBClient extracts the @rid and returns it to the submit_score handler.

    4. Backend Response (Rust)

    • The submit_score handler constructs a JSON response { "status": "success", "record_id": rid } and sends it back to the frontend.

    5. Frontend Update (Svelte)

    • The submitScore function in api.js receives the response and returns it to handleSubmit.
    • If the response indicates success, handleSubmit clears the form, updates the message, and calls fetchTopScores to refresh the leaderboard.
    • fetchTopScores makes a GET request to http://localhost:8080/api/top_scores.

    6. Backend API (Rust) - Fetching Top Scores

    • The Actix-web server receives the GET /api/top_scores request.
    • The get_top_scores handler is invoked, which uses ArcadeDBClient to call get_top_scores.
    • get_top_scores makes a POST request to ArcadeDB's REST API at http://localhost:2480/api/v1/query/HighScoresDB with a query to select the top 10 scores ordered by score in descending order.
    • ArcadeDB executes the query and returns the results as JSON.

    7. Backend Response (Rust) - Top Scores

    • The get_top_scores handler receives the results, deserializes them into a Vec<HighScore>, and sends them back to the frontend as JSON.

    8. Frontend Update (Svelte) - Displaying Top Scores

    • The fetchTopScores function in api.js receives the response and returns it to App.svelte.
    • The topScores reactive variable is updated, causing the leaderboard table to re-render with the latest data.

    Step 5: Best Practices Demonstrated

    • Separation of Concerns: The frontend handles UI, the backend handles business logic, and the database handles persistence.
    • Error Handling: Both the backend and frontend handle errors gracefully, providing feedback to the user.
    • Type Safety: Rust's type system ensures robust backend code, while Svelte's reactivity simplifies frontend state management.
    • Asynchronous Programming: Both Rust (with async/await) and Svelte (with async functions) use modern asynchronous patterns for efficient I/O.
    • API Design: The backend exposes a RESTful API, making it easy to integrate with any frontend.
    • Modular Code: The backend is split into main.rs, models.rs, and db.rs, while the frontend uses a separate api.js for API calls.

    Step 6: Running the Full Application

    1. Start ArcadeDB:
      docker-compose up -d
      
    2. Start the backend:
      cd backend
      cargo run
      
    3. Start the frontend:
      cd frontend
      npm install
      npm run dev
      
    4. Open http://localhost:5173 in your browser, submit a score, and watch the leaderboard update.

    Step 7: Potential Improvements

    • Authentication: Add user authentication to prevent score tampering.
    • Validation: Add more robust input validation on both the frontend and backend.
    • Real-time Updates: Use WebSockets to push leaderboard updates to all connected clients.
    • Testing: Add unit and integration tests for both the frontend and backend.
    • Deployment: Containerize the backend and frontend for easy deployment.

    This example provides a solid foundation for understanding the flow of data in a full-stack application using Svelte, Rust, and ArcadeDB.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.