Library to Provide a Session management layer.
If you need help with this library or have suggestions please go to our Discord Group
Axum Database Sessions uses [tokio]
```toml
[dependencies]
axumdatabasesessions = { version = "4.0.0", features = [ "postgres-rustls"] } ```
default: [postgres-rustls]
sqlite-rustls: Sqlx 0.6.0 support for the self-contained SQLite database engine and rustls.
sqlite-native: Sqlx 0.6.0 support for the self-contained SQLite database engine and native-tls.
postgres-rustls: Sqlx 0.6.0 support for the Postgres database server and rustls.
postgres-native: Sqlx 0.6.0 support for the Postgres database server and native-tls.
mysql-rustls: Sqlx 0.6.0 support for the MySQL/MariaDB database server and rustls.
mysql-native: Sqlx 0.6.0 support for the MySQL/MariaDB database server and native-tls.
redis-db: redis 0.21.5 session support.
```rust norun use sqlx::{ConnectOptions, postgres::{PgPoolOptions, PgConnectOptions}}; use std::net::SocketAddr; use axumdatabase_sessions::{AxumSession, AxumPgPool, AxumSessionConfig, AxumSessionStore, AxumSessionLayer}; use axum::{ Router, routing::get, };
async fn main() {
let poll = connect_to_database().await.unwrap();
//This Defaults as normal Cookies.
//To enable Private cookies for integrity, and authenticity please check the next Example.
let session_config = AxumSessionConfig::default()
.with_table_name("test_table");
let session_store = AxumSessionStore::<AxumPgPool>::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
count += 1;
session.set("count", count).await;
count.to_string()
}
async fn connecttodatabase() -> anyhow::Result
To enable private cookies for confidentiality, integrity, and authenticity. When a Key is set it will automatically set the Cookie into an encypted Private cookie which both protects the cookies data from prying eye's it also ensures the authenticity of the cookie.
```rust norun use sqlx::{ConnectOptions, postgres::{PgPoolOptions, PgConnectOptions}}; use std::net::SocketAddr; use axumdatabase_sessions::{AxumSession, AxumPgPool, AxumSessionConfig, AxumSessionStore, AxumSessionLayer, AxumSessionMode, Key}; use axum::{ Router, routing::get, };
async fn main() { let sessionconfig = AxumSessionConfig::default() .withtablename("testtable") // 'Key::generate()' will generate a new key each restart of the server. // If you want it to be more permanent then generate and set it to a config file. // If withkey() is used it will set all cookies as private, which guarantees integrity, and authenticity. .withkey(Key::generate());
let session_store = AxumSessionStore::<AxumPgPool>::new(None, session_config);
session_store.initiate().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();
} ```
To use Axumdatabasesession in non_persistant mode Set the client to None and import AxumNullPool. AxumNullPool is always loaded and can be used where you do not want to include any database within the build.
```rust norun use sqlx::{ConnectOptions, postgres::{PgPoolOptions, PgConnectOptions}}; use std::net::SocketAddr; use axumdatabase_sessions::{AxumSession, AxumNullPool, AxumSessionConfig, AxumSessionStore, AxumSessionLayer}; use axum::{ Router, routing::get, };
async fn main() { let sessionconfig = AxumSessionConfig::default() .withtablename("testtable");
let session_store = AxumSessionStore::<AxumNullPool>::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
count += 1;
session.set("count", count).await;
count.to_string()
}
```
To use Axumdatabasesession with session mode set as Storable.
```rust norun use sqlx::{ConnectOptions, postgres::{PgPoolOptions, PgConnectOptions}}; use std::net::SocketAddr; use axumdatabase_sessions::{AxumSession, AxumPgPool, AxumSessionConfig, AxumSessionStore, AxumSessionLayer, AxumSessionMode}; use axum::{ Router, routing::get, };
async fn main() { let sessionconfig = AxumSessionConfig::default() .withtablename("testtable").with_mode(AxumSessionMode::AcceptedOnly);
let session_store = AxumSessionStore::<AxumPgPool>::new(None, session_config);
session_store.initiate().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
// Allow the Session data to be keep in memory and the database for the lifetime.
session.set_store(true).await;
count += 1;
session.set("count", count).await;
count.to_string()
}
```