Registry

outbox! registers record types under the names they track and returns the registry; a name written twice does not compile.

The registry is an Outbox: the pool its records live in and the list of names it tracks, each with its record type. outbox! { pool: pool, "orders" => OrderOutbox } builds one on a pool, and without pool: it starts without one, for the set_pool shape. Each registration builds the record's default statements once, from its table's description and the database's built-in dialect. The registry is cheap to clone, and every clone reads the same pool and the same names. It hands out the two middlewares, the republish and wrap.

One record type may track several names, so one table serves them all. Each registration republishes only the records of its own name. A name has one record type.

By hand, Outbox::new takes the pool and Outbox::deferred starts without one. track::<Record, Name>() registers a record type under a name that is a type, a TrackedName, and a name tracked twice stops the build. register::<Record>(name) takes the name as a &'static str, for a name the service computes, and panics on a repeated name when the app is built. The registry's type lists every record type it holds, so a handle carries no lookup table and an unregistered name costs only the comparisons.

Example

OrderOutbox tracks both orders and refunds: the replies of place and cancel are recorded in the one outbox table, each under its own name.

Macros
Manual

examples/sqlx_outbox_registry.rs
use ruststream_sqlx::outbox;

fn service(pool: SqlitePool) -> impl App {
    // Each name has one record type; a name written twice does not compile.
    let tracking = outbox! {
        pool: pool,
        "orders" => OrderOutbox,
        "refunds" => OrderOutbox,
    };
    RustStream::new(AppInfo::new("orders", "0.1.0"))
        .layer(tracking.layer())
        .publish_layer(tracking.publish_layer())
        .with_broker(MemoryBroker::new(), |b| {
            b.include(place).out_reply(Publish);
            b.include(cancel).out_reply(Publish);
            b.include(fulfil);
            b.include(pay_back);
            b.after_startup(Publish, tracking.republish());
        })
}

examples/manual/sqlx_outbox_registry.rs
use ruststream_sqlx::outbox::{Outbox, TrackedName};

/// The name `OrderPlaced` is published under.
struct Orders;

impl TrackedName for Orders {
    const NAME: &'static str = "orders";
}

/// The name `RefundDue` is published under.
struct Refunds;

impl TrackedName for Refunds {
    const NAME: &'static str = "refunds";
}

fn service(pool: SqlitePool) -> impl App {
    // Each name has one record type; a name tracked twice stops the build.
    let tracking = Outbox::new(pool)
        .track::<OrderOutbox, Orders>()
        .track::<OrderOutbox, Refunds>();
    RustStream::new(AppInfo::new("orders", "0.1.0"))
        .layer(tracking.layer())
        .publish_layer(tracking.publish_layer())
        .with_broker(MemoryBroker::new(), |b| {
            b.include(subscriber("checkout", Place).reply().build())
                .out_reply(Publish);
            b.include(subscriber("cancellations", Cancel).reply().build())
                .out_reply(Publish);
            b.include(subscriber("orders", Fulfil).build());
            b.include(subscriber("refunds", PayBack).build());
            b.after_startup(Publish, tracking.republish());
        })
}

Example​

Example