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, migrator};
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?;
    migrator().run(&pool).await?;
     
    // Create handler
    let handler = PostgresHandler::<MyBodyType, MyBodyType>::new("postgresql://user:pass@localhost/db").await?;
    Ok(())
}

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 fn with_path_filter(self, filter: PathFilter) -> Self

Add path filtering to only log requests for specific URI prefixes.

Examples

use outlet_postgres::{PostgresHandler, PathFilter};

use serde_json::Value;
let handler = PostgresHandler::<Value, Value>::new("postgresql://user:pass@localhost/db")
    .await?
    .with_path_filter(PathFilter {
        allowed_prefixes: vec!["/api/".to_string(), "/webhook/".to_string()],
        blocked_prefixes: vec!["/api/health".to_string()],
    });

pub fn with_path_prefix(self, prefix: &str) -> Self

Add simple path prefix filtering - only log requests starting with the given prefix.

Examples

use outlet_postgres::PostgresHandler;

use serde_json::Value;
let handler = PostgresHandler::<Value, Value>::new("postgresql://user:pass@localhost/db")
    .await?
    .with_path_prefix("/api/");

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

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)

Handle a captured HTTP request.

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

Handle a captured HTTP response.