Struct PostgresHandler 

pub struct PostgresHandler<P = PgPool, TReq = Value, TRes = Value>
where
    P: PoolProvider,
    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:

• P: Pool provider implementing PoolProvider trait for read/write routing
• TReq and TRes: Request and response body types for JSONB serialization

Use serde_json::Value for flexible JSON storage, or custom structs for typed storage.

Implementations

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

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

pub fn with_request_serializer<F>(self, serializer: F) -> Self

where F: Fn(&RequestData) -> Result<TReq, SerializationError> + Send + Sync + 'static,

Add a custom request body serializer.

The serializer function takes raw bytes and should return a Result<TReq, String>. If the serializer succeeds, the result will be stored as JSONB and body_parsed will be true. If it fails, the raw content will be stored as a UTF-8 string and body_parsed will be false.

Panics

This will panic if the serializer succeeds but the resulting TReq value cannot be converted to JSON via serde_json::to_value(). This indicates a bug in the Serialize implementation of TReq and should be fixed by the caller.

pub fn with_response_serializer<F>(self, serializer: F) -> Self

where F: Fn(&RequestData, &ResponseData) -> Result<TRes, SerializationError> + Send + Sync + 'static,

Add a custom response body serializer.

The serializer function takes raw bytes and should return a Result<TRes, String>. If the serializer succeeds, the result will be stored as JSONB and body_parsed will be true. If it fails, the raw content will be stored as a UTF-8 string and body_parsed will be false.

Panics

This will panic if the serializer succeeds but the resulting TRes value cannot be converted to JSON via serde_json::to_value(). This indicates a bug in the Serialize implementation of TRes and should be fixed by the caller.

pub async fn from_pool_provider( pool_provider: P, ) -> Result<Self, PostgresHandlerError>

Create a PostgreSQL handler from a pool provider.

Use this if you want to use a custom pool provider implementation (such as DbPools for read/write separation). This will NOT run migrations - use migrator() to run migrations separately.

Arguments

• pool_provider - Pool provider implementing PoolProvider trait

Examples

use outlet_postgres::{PostgresHandler, DbPools, migrator};
use sqlx::postgres::PgPoolOptions;
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 primary = PgPoolOptions::new()
        .connect("postgresql://user:pass@primary/db").await?;
    let replica = PgPoolOptions::new()
        .connect("postgresql://user:pass@replica/db").await?;

    // Run migrations on primary
    migrator().run(&primary).await?;

    // Create handler with read/write separation
    let pools = DbPools::with_replica(primary, replica);
    let handler = PostgresHandler::<_, MyBodyType, MyBodyType>::from_pool_provider(pools).await?;
    Ok(())
}

pub fn repository(&self) -> RequestRepository<P, 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.

impl<TReq, TRes> PostgresHandler<PgPool, 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, migrator};
use serde::{Deserialize, Serialize};

#[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?;
    migrator().run(&pool).await?;

    // Create handler
    let handler = PostgresHandler::<_, MyBodyType, 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, migrator};
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
    migrator().run(&pool).await?;

    // Create handler
    let handler = PostgresHandler::<_, MyBodyType, MyBodyType>::from_pool(pool).await?;
    Ok(())
}

Trait Implementations

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

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where P: PoolProvider, 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)

Handle a captured HTTP request.

async fn handle_response( &self, request_data: RequestData, response_data: ResponseData, )

Handle a captured HTTP response.