wtx 0.43.1

A collection of different transport implementations and related tools focused primarily on web technologies.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use crate::{database::client::postgres::PostgresError, misc::UriRef};

/// Configuration
#[derive(Debug, PartialEq, Eq)]
pub struct Config<'data> {
  pub(crate) application_name: &'data str,
  pub(crate) channel_binding: ChannelBinding,
  pub(crate) db: &'data str,
  pub(crate) password: &'data str,
  pub(crate) user: &'data str,
}

impl<'data> Config<'data> {
  /// Unwraps the elements from an URI.
  pub fn from_uri(uri: &'data UriRef<'_>) -> crate::Result<Config<'data>> {
    let db = uri.path().get(1..).unwrap_or_default();
    let password = uri.password();
    let user = uri.user();
    let mut this =
      Self { application_name: "", channel_binding: ChannelBinding::Prefer, db, password, user };
    for (key, value) in uri.query_params() {
      this.set_param(key, value)?;
    }
    Ok(this)
  }

  fn set_param(&mut self, key: &str, value: &'data str) -> crate::Result<()> {
    match key {
      "application_name" => {
        self.application_name = value;
      }
      "channel_binding" => {
        let channel_binding = match value {
          "disable" => ChannelBinding::Disable,
          "prefer" => ChannelBinding::Prefer,
          "require" => ChannelBinding::Require,
          _ => return Err(PostgresError::UnknownConfigurationParameter.into()),
        };
        self.channel_binding = channel_binding;
      }
      _ => return Err(PostgresError::UnknownConfigurationParameter.into()),
    }
    Ok(())
  }

  /// Database
  #[inline]
  pub fn db(&self) -> &str {
    self.db
  }

  /// Changes the database
  #[inline]
  pub fn set_db<'value>(&mut self, value: &'value str)
  where
    'value: 'data,
  {
    self.db = value;
  }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum ChannelBinding {
  Disable,
  Prefer,
  Require,
}

#[cfg(test)]
mod tests {
  use crate::database::client::postgres::{Config, config::ChannelBinding};

  #[test]
  fn from_uri() {
    let uri = "postgres://ab:cd@ef:5432/gh?application_name=ij&channel_binding=disable".into();
    let config = Config::from_uri(&uri).unwrap();
    assert_eq!(config.application_name, "ij");
    assert_eq!(config.channel_binding, ChannelBinding::Disable);
    assert_eq!(config.db, "gh");
    assert_eq!(config.password, "cd");
    assert_eq!(config.user, "ab");
  }
}