Exemples d'implémentation¶

// database.hpp
// Wrapper C++ RAII autour de l'API C de SQLite3
#pragma once
#include <sqlite3.h>
#include <string>
#include <vector>
#include <optional>
#include <stdexcept>

// Representation d'un item en memoire
struct Item {
    int         id    = 0;
    std::string nom;
    double      prix  = 0.0;
    int         stock = 0;
};

// Exception levee en cas d'erreur SQLite
class DbException : public std::runtime_error {
public:
    explicit DbException(const std::string& msg) : std::runtime_error(msg) {}
};

class Database {
public:
    // Constructeur : ouvre ou cree le fichier SQLite et cree la table si necessaire
    explicit Database(const std::string& chemin);

    // Destructeur : ferme la connexion (RAII)
    ~Database();

    // Pas de copie — une seule connexion par instance
    Database(const Database&)            = delete;
    Database& operator=(const Database&) = delete;

    std::vector<Item>    listerItems()                  const;
    std::optional<Item>  trouverItem(int id)            const;
    Item                 creerItem(const std::string& nom, double prix, int stock);
    bool                 mettreAJourItem(const Item& item);
    bool                 supprimerItem(int id);

private:
    sqlite3* db_ = nullptr;

    // Execution d'une requete sans resultat (INSERT, UPDATE, DELETE, CREATE)
    void executer(const std::string& sql);
};

// database.cpp
#include "database.hpp"
#include <stdexcept>

Database::Database(const std::string& chemin) {
    int rc = sqlite3_open(chemin.c_str(), &db_);
    if (rc != SQLITE_OK) {
        throw DbException(std::string("Impossible d'ouvrir la DB : ") + sqlite3_errmsg(db_));
    }
    executer(R"(
        CREATE TABLE IF NOT EXISTS items (
            id    INTEGER PRIMARY KEY AUTOINCREMENT,
            nom   TEXT    NOT NULL,
            prix  REAL    NOT NULL,
            stock INTEGER NOT NULL DEFAULT 0
        )
    )");
}

Database::~Database() {
    if (db_) sqlite3_close(db_);
}

void Database::executer(const std::string& sql) {
    char* msg = nullptr;
    int rc = sqlite3_exec(db_, sql.c_str(), nullptr, nullptr, &msg);
    if (rc != SQLITE_OK) {
        std::string err(msg ? msg : "Erreur inconnue");
        sqlite3_free(msg);
        throw DbException(err);
    }
}

std::vector<Item> Database::listerItems() const {
    std::vector<Item> items;
    sqlite3_stmt* stmt = nullptr;

    sqlite3_prepare_v2(db_, "SELECT id, nom, prix, stock FROM items", -1, &stmt, nullptr);
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        Item item;
        item.id    = sqlite3_column_int(stmt, 0);
        item.nom   = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
        item.prix  = sqlite3_column_double(stmt, 2);
        item.stock = sqlite3_column_int(stmt, 3);
        items.push_back(std::move(item));
    }
    sqlite3_finalize(stmt);
    return items;
}

std::optional<Item> Database::trouverItem(int id) const {
    sqlite3_stmt* stmt = nullptr;
    sqlite3_prepare_v2(db_, "SELECT id, nom, prix, stock FROM items WHERE id = ?",
                       -1, &stmt, nullptr);
    sqlite3_bind_int(stmt, 1, id);

    std::optional<Item> resultat;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        Item item;
        item.id    = sqlite3_column_int(stmt, 0);
        item.nom   = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
        item.prix  = sqlite3_column_double(stmt, 2);
        item.stock = sqlite3_column_int(stmt, 3);
        resultat   = std::move(item);
    }
    sqlite3_finalize(stmt);
    return resultat;
}

Item Database::creerItem(const std::string& nom, double prix, int stock) {
    sqlite3_stmt* stmt = nullptr;
    sqlite3_prepare_v2(db_,
        "INSERT INTO items (nom, prix, stock) VALUES (?, ?, ?)", -1, &stmt, nullptr);
    sqlite3_bind_text(stmt, 1, nom.c_str(), -1, SQLITE_STATIC);
    sqlite3_bind_double(stmt, 2, prix);
    sqlite3_bind_int(stmt, 3, stock);

    if (sqlite3_step(stmt) != SQLITE_DONE)
        throw DbException("Echec insertion");
    sqlite3_finalize(stmt);

    Item item;
    item.id    = static_cast<int>(sqlite3_last_insert_rowid(db_));
    item.nom   = nom;
    item.prix  = prix;
    item.stock = stock;
    return item;
}

bool Database::mettreAJourItem(const Item& item) {
    sqlite3_stmt* stmt = nullptr;
    sqlite3_prepare_v2(db_,
        "UPDATE items SET nom=?, prix=?, stock=? WHERE id=?", -1, &stmt, nullptr);
    sqlite3_bind_text(stmt, 1, item.nom.c_str(), -1, SQLITE_STATIC);
    sqlite3_bind_double(stmt, 2, item.prix);
    sqlite3_bind_int(stmt, 3, item.stock);
    sqlite3_bind_int(stmt, 4, item.id);
    sqlite3_step(stmt);
    int rows = sqlite3_changes(db_);
    sqlite3_finalize(stmt);
    return rows > 0;
}

bool Database::supprimerItem(int id) {
    sqlite3_stmt* stmt = nullptr;
    sqlite3_prepare_v2(db_, "DELETE FROM items WHERE id = ?", -1, &stmt, nullptr);
    sqlite3_bind_int(stmt, 1, id);
    sqlite3_step(stmt);
    int rows = sqlite3_changes(db_);
    sqlite3_finalize(stmt);
    return rows > 0;
}

// handlers.cpp
// Compilation : g++ -std=c++17 -Wall -Ithird_party src/*.cpp -lsqlite3 -lpthread
#include "handlers.hpp"
#include "database.hpp"
#include <nlohmann/json.hpp>
#include <httplib.h>
#include <string>

using json = nlohmann::json;

// Serialisation Item -> JSON
static json itemVersJson(const Item& item) {
    return {{"id", item.id}, {"nom", item.nom},
            {"prix", item.prix}, {"stock", item.stock}};
}

void enregistrerHandlers(httplib::Server& srv, Database& db) {

    // GET /items — liste tous les items
    srv.Get("/items", [&](const httplib::Request&, httplib::Response& res) {
        json tableau = json::array();
        for (const auto& item : db.listerItems())
            tableau.push_back(itemVersJson(item));
        res.set_content(tableau.dump(), "application/json");
    });

    // GET /items/:id — recupere un item par ID
    srv.Get(R"(/items/(\d+))", [&](const httplib::Request& req, httplib::Response& res) {
        int id = std::stoi(req.matches[1]);
        auto item = db.trouverItem(id);
        if (!item) {
            res.status = 404;
            res.set_content(R"({"error":"Item non trouve"})", "application/json");
            return;
        }
        res.set_content(itemVersJson(*item).dump(), "application/json");
    });

    // POST /items — cree un nouvel item
    srv.Post("/items", [&](const httplib::Request& req, httplib::Response& res) {
        try {
            auto body = json::parse(req.body);
            // Validation des champs obligatoires
            if (!body.contains("nom") || !body.contains("prix")) {
                res.status = 400;
                res.set_content(R"({"error":"Champs 'nom' et 'prix' requis"})",
                                "application/json");
                return;
            }
            auto item = db.creerItem(
                body["nom"].get<std::string>(),
                body["prix"].get<double>(),
                body.value("stock", 0)
            );
            res.status = 201;
            res.set_content(itemVersJson(item).dump(), "application/json");
        } catch (const json::exception& e) {
            res.status = 400;
            res.set_content(R"({"error":"JSON invalide"})", "application/json");
        }
    });

    // PUT /items/:id — mise a jour complete
    srv.Put(R"(/items/(\d+))", [&](const httplib::Request& req, httplib::Response& res) {
        int id = std::stoi(req.matches[1]);
        try {
            auto body = json::parse(req.body);
            Item item;
            item.id    = id;
            item.nom   = body["nom"].get<std::string>();
            item.prix  = body["prix"].get<double>();
            item.stock = body.value("stock", 0);

            if (!db.mettreAJourItem(item)) {
                res.status = 404;
                res.set_content(R"({"error":"Item non trouve"})", "application/json");
                return;
            }
            res.set_content(itemVersJson(item).dump(), "application/json");
        } catch (const json::exception&) {
            res.status = 400;
            res.set_content(R"({"error":"JSON invalide"})", "application/json");
        }
    });

    // DELETE /items/:id — supprime un item
    srv.Delete(R"(/items/(\d+))", [&](const httplib::Request& req, httplib::Response& res) {
        int id = std::stoi(req.matches[1]);
        if (!db.supprimerItem(id)) {
            res.status = 404;
            res.set_content(R"({"error":"Item non trouve"})", "application/json");
            return;
        }
        res.status = 204;
    });
}

// main.cpp
#include "handlers.hpp"
#include "database.hpp"
#include <httplib.h>
#include <iostream>

int main() {
    Database db("items.db");
    httplib::Server srv;

    enregistrerHandlers(srv, db);

    std::cout << "API demarree sur http://localhost:8080\n";
    srv.listen("0.0.0.0", 8080);
    return 0;
}