AxumdatabaseSessions

Library to Provide a Sqlx Database Session management layer.

You must choose only one of ['postgres', 'mysql', 'sqlite'] features to use this library.

Install

Axum Database Sessions uses [tokio] runtime along with ['sqlx']; it supports [native-tls] and [rustls] TLS backends. When adding the dependency, you must chose a database feature that is DatabaseType and a tls backend. You can only choose one database type and one TLS Backend. By default, GDPR mode is enabled due to this it will require you to add an acceptance to your website before a Session or Cookie with Session id can be saved. If you want to disable GDPR mode, please see the examples.

```toml

Cargo.toml

[dependencies]

Postgres + rustls

axumdatabasesessions = { version = "1.2", features = [ "postgres", "rustls"] } ```

Cargo Feature Flags

sqlite: Sqlx support for the self-contained SQLite database engine. postgres: Sqlx support for the Postgres database server. mysql: Sqlx support for the MySQL/MariaDB database server. native-tls: Use the tokio runtime and native-tls TLS backend. rustls: Use the tokio runtime and rustls TLS backend.

Example

```rust norun use sqlx::{ConnectOptions, postgres::{PgPoolOptions, PgConnectOptions}}; use std::net::SocketAddr; use axumdatabase_sessions::{AxumSession, AxumSessionConfig, AxumSessionStore, AxumSessionLayer}; use axum::{ Router, routing::get, };

[tokio::main]

async fn main() {

let poll = connect_to_database().await.unwrap();

let session_config = AxumSessionConfig::default()
    .with_table_name("test_table");

let session_store = AxumSessionStore::new(Some(poll.clone().into()), session_config);
session_store.migrate().await.unwrap();

// build our application with some routes
let app = Router::new()
    .route("/greet", get(greet))
    .layer(AxumSessionLayer::new(session_store));

// run it
let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
tracing::debug!("listening on {}", addr);
axum::Server::bind(&addr)
    .serve(app.into_make_service())
    .await
    .unwrap();

}

async fn greet(session: AxumSession) -> String { let mut count: usize = session.get("count").await.unwrap_or(0);

//We set this to tell the system the user accepted the cookies.
//Otherwise the Session wont get stored and the Session ID is not sent as a cookie.
//The only Cookie that is always Sent is the Session Accepted Cookie.
session.set_accepted(true).await;
count += 1;
session.set("count", count).await;

count.to_string()

}

async fn connecttodatabase() -> anyhow::Result> { // ... unimplemented!() } ```

To use Axumdatabasesession in non_persistant mode Set the client to None.

Example

```rust norun use sqlx::{ConnectOptions, postgres::{PgPoolOptions, PgConnectOptions}}; use std::net::SocketAddr; use axumdatabase_sessions::{AxumSession, AxumSessionConfig, AxumSessionStore, AxumSessionLayer}; use axum::{ Router, routing::get, };

[tokio::main]

async fn main() { let sessionconfig = AxumSessionConfig::default() .withtablename("testtable");

let session_store = AxumSessionStore::new(None, session_config);

// build our application with some routes
let app = Router::new()
    .route("/greet", get(greet))
    .layer(AxumSessionLayer::new(session_store));

// run it
let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
tracing::debug!("listening on {}", addr);
axum::Server::bind(&addr)
    .serve(app.into_make_service())
    .await
    .unwrap();

}

async fn greet(session: AxumSession) -> String { let mut count: usize = session.get("count").await.unwrapor(0); //We set this to tell the system the user accepted the cookies. //Otherwise the Session wont get stored and the Session ID is not sent as a cookie. //The only Cookie that is always Sent is the Session Accepted Cookie. session.setaccepted(true).await; count += 1; session.set("count", count).await;

count.to_string()

}

```

To use Axumdatabasesession with GDPR mode disabled .

Example

```rust norun use sqlx::{ConnectOptions, postgres::{PgPoolOptions, PgConnectOptions}}; use std::net::SocketAddr; use axumdatabase_sessions::{AxumSession, AxumSessionConfig, AxumSessionStore, AxumSessionLayer}; use axum::{ Router, routing::get, };

[tokio::main]

async fn main() { let sessionconfig = AxumSessionConfig::default() .withtablename("testtable").with_gdpr(false);

let session_store = AxumSessionStore::new(None, session_config);
session_store.migrate().await.unwrap();

// build our application with some routes
let app = Router::new()
    .route("/greet", get(greet))
    .layer(AxumSessionLayer::new(session_store));

// run it
let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
tracing::debug!("listening on {}", addr);
axum::Server::bind(&addr)
    .serve(app.into_make_service())
    .await
    .unwrap();

}

//No need to set the sessions accepted or not with gdpr mode disabled async fn greet(session: AxumSession) -> String { let mut count: usize = session.get("count").await.unwrap_or(0); count += 1; session.set("count", count).await;

count.to_string()

}

```

Help

If you need help with this library please go to our Discord Group