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.

```toml

Cargo.toml

[dependencies]

Postgres + rustls

axumdatabasesessions = { version = "2.0.1", 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);

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.unwrap_or(0);

count += 1;
session.set("count", count).await;

count.to_string()

}

```

To use Axumdatabasesession with session mode set as Storable.

Example

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

[tokio::main]

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

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);

// 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()

}

```

Help

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