Struct PostgresHandler 

pub struct PostgresHandler<TReq = Value, TRes = Value>
where
    TReq: for<'de> Deserialize<'de> + Serialize + Send + Sync + 'static,
    TRes: for<'de> Deserialize<'de> + Serialize + Send + Sync + 'static,
{ /* private fields */ }

PostgreSQL handler for outlet middleware.

Implements the RequestHandler trait to log HTTP requests and responses to PostgreSQL. Request and response bodies are serialized to JSONB fields.

Generic over TReq and TRes which represent the request and response body types that should implement Deserialize for parsing and Serialize for database storage as JSONB. Use serde_json::Value for flexible JSON storage, or custom structs for typed storage.

Implementations

impl<TReq, TRes> PostgresHandler<TReq, TRes>

where TReq: for<'de> Deserialize<'de> + Serialize + Send + Sync + 'static, TRes: for<'de> Deserialize<'de> + Serialize + Send + Sync + 'static,

pub async fn new(database_url: &str) -> Result<Self, PostgresHandlerError>

Create a new PostgreSQL handler with a connection pool.

This will connect to the database but will NOT run migrations. Use migrator() to get a migrator and run migrations separately.

Arguments

• database_url - PostgreSQL connection string

Examples

use outlet_postgres::PostgresHandler;
use serde::{Deserialize, Serialize};
use serde_json::Value;

#[derive(Deserialize, Serialize)]
struct MyBodyType {
    id: u64,
    name: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Run migrations first
    let pool = sqlx::PgPool::connect("postgresql://user:pass@localhost/db").await?;
    PostgresHandler::<MyBodyType, MyBodyType>::migrator().run(&pool).await?;
     
    // Create handler
    let handler = PostgresHandler::<MyBodyType>::new("postgresql://user:pass@localhost/db").await?;
    Ok(())
}

pub async fn from_pool(pool: PgPool) -> Result<Self, PostgresHandlerError>

Create a PostgreSQL handler from an existing connection pool.

Use this if you already have a connection pool and want to reuse it. This will NOT run migrations - use migrator() to run migrations separately.

Arguments

• pool - Existing PostgreSQL connection pool

Examples

use outlet_postgres::PostgresHandler;
use sqlx::PgPool;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize)]
struct MyBodyType {
    id: u64,
    name: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let pool = PgPool::connect("postgresql://user:pass@localhost/db").await?;
     
    // Run migrations first
    PostgresHandler::<MyBodyType, MyBodyType>::migrator().run(&pool).await?;
     
    // Create handler
    let handler = PostgresHandler::<MyBodyType>::from_pool(pool).await?;
    Ok(())
}

pub fn migrator() -> Migrator

Get the migrator for running outlet-postgres database migrations.

This returns a SQLx migrator that can be used to set up the required http_requests and http_responses tables. The consuming application is responsible for running these migrations at the appropriate time and in the appropriate database schema.

Examples

use outlet_postgres::PostgresHandler;
use sqlx::{PgPool, Executor};
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let pool = PgPool::connect("postgresql://user:pass@localhost/db").await?;
     
    // Run outlet migrations in a specific schema
    sqlx::query("SET search_path = 'outlet'").execute(&pool).await?;
    PostgresHandler::<Value, Value>::migrator().run(&pool).await?;
    sqlx::query("SET search_path = 'public'").execute(&pool).await?;
     
    // Create handler with schema-specific pool configured for outlet schema
    let outlet_pool = sqlx::postgres::PgPoolOptions::new()
        .after_connect(|conn, _meta| {
            Box::pin(async move {
                conn.execute("SET search_path = 'outlet';").await?;
                Ok(())
            })
        })
        .connect("postgresql://user:pass@localhost/db")
        .await?;
    let handler = PostgresHandler::<Value, Value>::from_pool(outlet_pool).await?;
    Ok(())
}

pub fn repository(&self) -> RequestRepository<TReq, TRes>

Get a repository for querying logged requests and responses.

Returns a RequestRepository with the same type parameters as this handler, allowing for type-safe querying of request and response bodies.

Trait Implementations

impl<TReq, TRes> Clone for PostgresHandler<TReq, TRes>

where TReq: for<'de> Deserialize<'de> + Serialize + Send + Sync + 'static + Clone, TRes: for<'de> Deserialize<'de> + Serialize + Send + Sync + 'static + Clone,

fn clone(&self) -> PostgresHandler<TReq, TRes>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<TReq, TRes> RequestHandler for PostgresHandler<TReq, TRes>

where TReq: for<'de> Deserialize<'de> + Serialize + Send + Sync + 'static, TRes: for<'de> Deserialize<'de> + Serialize + Send + Sync + 'static,

async fn handle_request(&self, data: RequestData, correlation_id: u64)

Handle a captured HTTP request.

async fn handle_response(&self, data: ResponseData, correlation_id: u64)

Handle a captured HTTP response.