how to add db_connection to ServiceCollection by specifying database_url? so that the database_url is not empty when get_pool is called

[shulgastanslv]

#[injectable(DbContext)]
#[derive(Default)]
pub struct DbConnection {
    pub database_url: String,
}


pub trait DbContext {
    fn get_pool(&self) -> DbPool;
}

impl DbContext for DbConnection {

    fn get_pool(&self) -> DbPool {

        if self.database_url.is_empty() {
            panic!();
        }

        let manager = ConnectionManager::<PgConnection>::new(&self.database_url);

        r2d2::Pool::new(manager).unwrap()
    }
}

[commonsensesoftware]

Great question! At some point, many injectable components will use a set of primitives. While injecting primitives is possible, they become difficult to manage since they cannot use macros and are not unique. There are several solutions, but here are a few.

Option 1

The first thing you likely want is a container for the options (e.g. settings) for the connection.

pub struct DbConnectionOptions {
    pub database_url: String,
}

You can imagine that this struct might also have additional members such as retries and so on. This would require a small amount of refactoring:

use di::*;

#[injectable(DbContext)]
pub struct DbConnection {
    options: Ref<DbConnectionOptions>,
}

pub trait DbContext {
    fn get_pool(&self) -> DbPool;
}

impl DbContext for DbConnection {
    fn get_pool(&self) -> DbPool {
        let manager = ConnectionManager::<PgConnection>::new(&self.options.database_url);
        r2d2::Pool::new(manager).unwrap()
    }
}

Setting it up is pretty straight forward, but DbConnectionOptions almost certainly requires the long-form setup because the primitives are not injectable.

use di::*;

let provider = ServiceCollection::new()
    .add(DbConnection::transient())
    .add(transient_as_self::<DbConnectionOptions>()
         .from(|_| Ref::new(DbConnectionOptions {
            database_url: String::from("<str>")
     }))
    .build_provider()
    .unwrap();

Option 2

The previous setup is a common scenario, which is the primary purpose of the more-options sister crate. The definition using Options looks very similar:

use di::*;
use options::Options;

#[injectable(DbContext)]
pub struct DbConnection {
    options: Ref<dyn Options<DbConnectionOptions>>,
}

pub trait DbContext {
    fn get_pool(&self) -> DbPool;
}

impl DbContext for DbConnection {
    fn get_pool(&self) -> DbPool {
        r2d2::Pool::new(
            ConnectionManager::<PgConnection>::new(
                &self.options.value().database_url)
        ).unwrap()
    }
}

The more interesting part is how things are configured. Options can be configured as part of DI. You can even add validation. I haven't figured out how to avoid a panic! on validation failure, but that might be ok, at least for now, since the application is essentially in a bad state.

use di::*;
use options::{*, ext::*};

let provider = ServiceCollection::new()
    .add_options::<DbConnectionOptions>()
    .configure(|options| options.database_url = "<url>")
    .validate(|options| !options.database_url.is_empty(), "Database URL is unset")
    .add(DbConnection::transient())
    .build_provider()
    .unwrap();

That's all fine and well, but it's often the case that you'll configure something like a database connection from configuration. The more-config sister crate can be combined with more-di and more-options to bring all of the pieces together.

Let's say you have the configuration file (but it could be any source) appsettings.json with:

{
  "data": {
    "database_url": "<str>"
  }
}

We need a minor refactoring of our options so they can be deserialized via serde:

use serde::Deserialize;

#[default(Deserialize)]
pub struct DbConnectionOptions {
    pub database_url: String,
}

We can combine all of these together as follows:

use config::{*, ext::*};
use di::*;
use options::{*, ext::*};

let config = DefaultConfigurationBuilder::new()
        .add_json_file("appsettings.json")
        .build()
        .unwrap()
        .as_config();

let provider = ServiceCollection::new()
    .add(DbConnection::transient())
    .apply_config_at::<DbConnectionOptions>(config, "data")
    .validate(|options| !options.database_url.is_empty(), "Database URL is unset")
    .build_provider()
    .unwrap();

This setup will load a configuration from a single JSON file (multiple sources are supported) and then register dyn Options<DbConnectionOptions> as a Singleton by binding the configuration at the key "data". When <dyn Options<DbConnectionOptions>>::value is invoked, it will deserialize the configuration section into the struct and run the validation.

Naturally, you are not required to do that, but all of these capabilities were meant to be complementary.

[shulgastanslv]

Thank you so much!!

[shulgastanslv]

cargo install more-config --all-features

here is nothing to install in `more-config v2.0.0`, because it has no binaries
`cargo install` is only for installing programs, and can't be used with libraries.
To use a library crate, add it as a dependency to a Cargo project with `cargo add`.

how to fix ? and if I add with cargo add, it doesn't work with di container. it doesn't find the function apply_config_at

let provider = ServiceCollection::new()
    .add(DbConnection::transient())
    .apply_config_at::<DbConnectionOptions>(config, "data")
    .validate(|options| !options.database_url.is_empty(), "Database URL is unset")
    .build_provider()
    .unwrap();

[shulgastanslv]

main.rs

 let configuration = DefaultConfigurationBuilder::new()
        .add_json_file("appsettings.json".is().optional())
        .build()
        .unwrap()
        .as_config();


    println!("database_url = {}", configuration.get("database_url").unwrap().as_str());


    let builder = ServiceBuilder::new();

    let mut provider = ServiceCollection::new()
    .add(DbConnection::transient())
    .apply_config::<DbConnectionOptions>(configuration, "database_url")
    .build_provider()
    .unwrap();

no method named `apply_config` found for mutable reference `&mut di::ServiceCollection` in the current scope method not found in `&mut ServiceCollection`

cargo.toml

more-options = "3.0.0"
more-config = { version = "2.0.0", features = ["serde_json", "json", "serde", "mem"] }
more-di = "3.0.0"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

[shulgastanslv]

ok, now error is here

    let config : Rc<dyn Configuration> =Rc::from(
        DefaultConfigurationBuilder::new()
            .add_json_file("appsettings.json")
            .build()
            .unwrap()
            .as_config());

    let builder = ServiceBuilder::new();

    let provider = builder
    .add_adapters()
    .add_infrastructure()
    .add_application()
    .build()
    .apply_config_at::<DbConnectionOptions>(config, "data")
    .build_provider().unwrap();


    let service = provider.get_required::<UserService>();

   service.save(CreateUserRequest::new("stas", "test"));

    Ok(())

thread 'main' panicked at /home/administrator/.cargo/registry/src/index.crates.io-6f17d22bba15001f/more-options-3.0.0/src/builder.rs:580:36:
called Option::unwrap() on a None value
note: run with RUST_BACKTRACE=1 environment variable to display a backtrace

[commonsensesoftware]

First, I noticed that I used cargo install instead of cargo add in the user guides. Silly mistake. I have fixed that in all user guides.

Sadly, I discovered that this was due to a bug I found. Somehow out of all the test cases, I missed this edge case. It was reported in more-rs-options#6, but I have since fixed and published it.

In putting together a working solution for you, I hit design snag that I apparently didn't have a test case for. Trait conversion isn't so simple in Rust (and I get why). This led to the problem that using apply_config_at will bind using named Options that you would have to retrieve via OptionsMonitor::get(Some("test")), when what you want is just Options::value. Rust will not allow the Box<dyn ConfigurationSection> to convert to Box<dyn Configuration> on its own. It was an easy fix, but I had to make several small changes and publish those.

[commonsensesoftware]

Let's say you have the following appsettings.json:

{
    "data": {
      "databaseUrl": "https://my.db.com/data"
    }
  }

This is proper Camel-casing for JSON. You'd likely have your options struct like:

#[derive(Default, Deserialize)]
pub struct DbOptions {
    #[serde(alias = "DatabaseUrl")]
    pub database_url: String,
}

Note that configuration keys are normalized to Pascal-case, but the lookup keys are case-insensitive.

Unless you copy the appsettings.json file as part of the build process, then you likely need to specify the relative path to the root of your workspace. In the world's simplest example, the binary will be under target/debug so you need to go up two levels. This example demonstrates binding your options from a particular configuration section as opposed to the entire configuration (which already worked as advertised). apply_config applies a configuration to options whereas apply_config_at applies a configuration section with the same key. This will result in the options having a name/key, when you probably aren't interested in that for the example. The ConfigurationSection trait implements the Configuration trait, so once I fixed/provided a conversion function, you can now bind it as you'd expect. That is also why the validation was not causing a panic. The named options were never requested so the validation never ran.

fn main() {
    let file = std::env::current_exe()
        .unwrap()
        .parent()
        .unwrap()
        .join("../../appsettings.json");
    let config = DefaultConfigurationBuilder::new()
        .add_json_file(file)
        .build()
        .unwrap();

    let provider = ServiceCollection::new()
        .apply_config::<DbOptions>(config.section("Data").as_config().into())
        .validate(
            |options| !options.database_url.is_empty(),
            "The database URL must be set.",
        )
        .add(DbConnection::transient())
        .build_provider()
        .unwrap();

    let db = provider.get_required::<DbConnection>();
    println!("Connecting to '{}'...", &db.database_url());
}

The following is a working E2E example:

more-di-issue-17.zip

You should be able to extract this file and simply run: cargo run

If you remove databaseUrl or make the value empty (e.g. "") and execute cargo run, you'll see the application panic (as expected) with a message that states "The database URL must be set.".

I hope that helps and unblocks you. Let me know if you have more questions or issues.

[shulgastanslv]

Thanks. Now is working!