How to handle generic fairing in route

[JohnCMoon]

I'm writing an app that supports both SQLite and Postgres. I had a question about how to handle the database fairings in a generic way. Today, I define two database structures:

#[database("postgres")]
pub struct MyPgDb(diesel::PgConnection);

#[database("sqlite")]
pub struct MySqliteDb(diesel::SqliteConnection);

At runtime, based on the config, I choose which fairing to attach and run migrations:

pub fn stage(db_backend: MyBackend) -> AdHoc {
    match db_backend {
        MyBackend::Sqlite => AdHoc::on_ignite("Database Stage", |rocket| async {
            rocket
                .attach(MySqliteDb::fairing())
                .attach(AdHoc::on_ignite("Sqlite Migrations", run_sqlite_migrations))
        }),
        MyBackend::Postgresql => AdHoc::on_ignite("Database Stage", |rocket| async {
            rocket
                .attach(MyPgDb::fairing())
                .attach(AdHoc::on_ignite("Postgres Migrations", run_pg_migrations))
        }),
    }
}

Then, I have a macro for each route implementation that I run for each backend:

macro_rules! impl_status {
    ($func:ident, $db:ty) => {
        #[get("/api/<_api_version>/status")]
        pub async fn $func(
            _api_version: &str,
            db: $db,
        ) -> Result<Json<StatusResponse>, Json<ApiError>> {
            let num_entries = db.run(move |conn| column.count().first(conn));
            match num_entries.await {
                Ok(n) => Ok(Json(StatusResponse {
                    status: "ok".to_string(),
                    num_entries: n
                })),
                Err(e) => Err(Json(ApiError::new(&e.to_string(), 0))),
            }
        }
    };
}
impl_status!(status_pg, MyPgDb);
impl_status!(status_sqlite, MySqliteDb);

Then, at runtime, I pass back the list of routes to mount (based on the config):

pub fn get_routes(backend: MyBackend) -> Vec<Route> {
    match backend {
        MyBackend::Postgresql => {
            routes![
                status_pg
                ...
            ]
        }
        MyBackend::Sqlite => {
            routes![
                status_sqlite
                ...
            ]
        }
    }
}

Is there a more straightforward or obvious way to do this? My solution feels clunky and non-idiomatic.

Thanks so much for your time!

[SergioBenitez]

The way I would do this is via an enum with a variant for each possible database, like this:

enum Database {
    Postgres(MyPgDb),
    MySqliteDb(MySqliteDb)
}

You can then implement FromRequest, Fairing, and a dispatching run() methods (and anything else you might need) as needed. Pseudocode below:

impl Fairing for Database {
    #[rocket::async_trait]
    fn info(&self) -> Info {
        name: "Database Muxer",
        kind: Kind::Ignite,
    }

    async fn on_ignite(&self, rocket: Rocket<Build>) -> fairing::Result {
        let rocket = match rocket.config().db_backend {
            Backend::Sqlite => rocket.attach(Sqlite::fairing()),
            Backend::Postgres => rocket.attach(Postgres::fairing()),
        };
    }
}

#[rocket::async_trait]
impl<'r> FromRequest<'r> for Database {
    type Error = ();

    async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
        // We could store something in managed state in `on_ignite()` above
        // that tells us which database we should be fetching to avoid calling
        // `from_request()` for each type.
        if let Success(db) = req.guard::<MyPgDb>().await {
            return Success(Database::Postgres(db));
        }

        if let Success(db) = req.guard::<MySqliteDb>().await {
            return Success(Database::Postgres(db));
        }

        Failure(todo!())
    }
}

impl Sentinel for Database {
    fn abort(rocket: &Rocket<Ignite>) -> bool {
        MyPgDb::abort(rocket) && MySqliteDb::abort(rocket)
    }
}

impl Database {
    async fn run_migrations<P: Phase>(rocket: &Rocket<P>) -> _ {
        if let Some(db) = MyPgDb::pool(rocket) {
            todo!()
        }

        if let Some(db) = MySqliteDb::pool(rocket) {
            todo!()
        }

        Err(todo!())
    }

    async fn count_cols(&self) -> _ {
        match self {
            Postgres(conn) => conn.run(...).await,
            MySqliteDb(conn) => conn.run(...).await,
        }
    }
}

Then you can just use it as normal:

pub async fn status(
    _api_version: &str,
    db: Database
) -> Result<Json<StatusResponse>, Json<ApiError>> {
    match db.count_cols().await {
        Ok(n) => Ok(Json(StatusResponse {
            status: "ok".to_string(),
            num_entries: n
        })),
        Err(e) => Err(Json(ApiError::new(&e.to_string(), 0))),
    }
}

I hope this makes sense.

[JohnCMoon]

That looks like a much cleaner implementation! Thank you so much for such a detailed reply and for all your work on Rocket! I'll see if this method will work for my use case and get back to you here. If it works well, I'd be happy to add a PR with a minimal example of this technique.