Struct Builder 

pub struct Builder { /* private fields */ }

Builds the application with routes of the caller’s own beside the API.

For a binary of your own that depends on this crate rather than a fork of it: webhooks, an endpoint that does several things in one transaction, anything that is not a table or a function.

use axum::{routing::post, Router};
use postrust_server::{AppState, Builder, Host};
use std::sync::Arc;

let hooks: Router<Arc<AppState>> = Router::new().route("/stripe", post(|| async { "ok" }));
let config = postrust_core::AppConfig::try_from_env()?;
let app = Builder::new(config, Host::SERVER)
    .nest("/hooks", hooks)
    .build()
    .await?;

A nested router is served with everything the API is served with: the CORS policy, the body limit, the OPTIONS handling and the shared AppState. Its routes are explicit routes, so in compatibility mode they are matched before the REST surface served at the root – a table that shares a prefix’s name is shadowed there, and stays reachable under /api.

Builder::layer is for what has to see every request rather than only the caller’s own: an authentication gate, a rate limit, a header every response carries.

Implementations

impl Builder

pub fn new(config: AppConfig, host: Host) -> Self

The application config asks for, on host, with nothing added yet.

pub fn nest( self, prefix: impl Into<String>, router: Router<Arc<AppState>>, ) -> Self

Serve router under prefix. May be called more than once.

The prefix is taken as a path: the leading slash is added if missing and a trailing one dropped, so "hooks", "/hooks" and "/hooks/" are one prefix. Nothing is checked until Builder::build, which refuses a prefix that is the root, that overlaps a path the server serves itself (RESERVED_PREFIXES, and /_ itself), or that overlaps another prefix given here. In compatibility mode, where REST is served at / as well, a prefix whose first segment is rpc or the name of a table or view in an exposed schema takes those paths from REST, and a warning says so at start-up. A prefix beneath /_, such as /_/hooks, is served beside the built-in /_/health and /_/ready.

pub fn layer<L>(self, layer: L) -> Self

where L: Layer<Route> + Clone + Send + Sync + 'static, L::Service: Service<Request> + Clone + Send + Sync + 'static, <L::Service as Service<Request>>::Response: IntoResponse + 'static, <L::Service as Service<Request>>::Error: Into<Infallible> + 'static, <L::Service as Service<Request>>::Future: Send + 'static,

Wrap the whole application in layer. May be called more than once.

Outermost, around every route the server serves and around its own layers too, so it sees each request first and each response last – including a preflight the CORS policy answers itself, and a refusal that never reaches a handler. Of several, the one given last is the outermost, as with Router::layer.

For something only the caller’s own routes need, put the layer on the router given to Builder::nest instead.

pub async fn build(self) -> Result<App>

Connect, load the schema cache and build the router.

The prefixes given to Builder::nest are checked first, before anything is connected to, so a clash is reported as an error rather than as a panic from the router – and without a database to find it. Otherwise as build.