Struct Repository 

pub struct Repository<Row>(/* private fields */);

The typed publish policy of a row with Publish: a message published through it becomes a row of Row’s table.

It names its table at compile time, so a publish costs a static call; a row without Publish does not compile as a policy.

Examples

use ruststream::OutgoingMessage;
use ruststream::prelude::*;
use ruststream_sqlx::{Inbox, InboxQueue, Publish, Repository, SqlxBroker};
use serde::{Deserialize, Serialize};
use sqlx::{PgConnection, PgPool, Postgres};

#[derive(Inbox, sqlx::FromRow)]
#[inbox(table = "jobs")]
pub struct Job {
    #[field(id, generated)]
    id: i64,
    #[field(group)]
    name: String,
    #[field(payload)]
    payload: Vec<u8>,
}

impl Publish<Postgres> for Job {
    async fn publish(
        conn: &mut PgConnection,
        message: &OutgoingMessage<'_>,
    ) -> Result<(), sqlx::Error> {
        sqlx::query("INSERT INTO jobs (name, payload) VALUES ($1, $2)")
            .bind(message.name())
            .bind(message.payload())
            .execute(conn)
            .await?;
        Ok(())
    }
}

#[derive(Deserialize)]
struct Signup {
    email: String,
}

#[derive(Serialize, Outgoing)]
#[outgoing(name = "welcome")]
struct Welcome {
    email: String,
}

#[subscriber(InboxQueue::<Job>::new("signups"), reply)]
async fn greet(signup: &Signup) -> Welcome {
    Welcome { email: signup.email.clone() }
}

pub fn app(pool: PgPool) -> RustStream {
    RustStream::new(AppInfo::new("signup", "0.1.0")).with_broker(SqlxBroker::new(pool), |b| {
        // The welcome becomes a row of `jobs` in group `welcome`, with no route to look up.
        b.include(greet).out_reply(Repository::<Job>::default());
    })
}

Trait Implementations

impl<Row> Clone for Repository<Row>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Row> Copy for Repository<Row>

impl<Row> Debug for Repository<Row>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Row> Default for Repository<Row>

fn default() -> Self

Returns the “default value” for a type.

impl<DB, D, Row> PublishPolicy<ConnectedSqlxBroker<DB, D>> for Repository<Row>

where DB: QueueDatabase, D: Dialect + 'static, Row: Publish<DB> + Events<DB>,

type Live = RepositoryPublisher<DB, Row>

The live form this policy pairs into: a Publisher for a leaf policy, or the live wiring form for a combinator stack (a typed publisher over a policy pairs into the same typed publisher over the live leaf).

fn pair( self, connected: &ConnectedSqlxBroker<DB, D>, ) -> impl Future<Output = Result<Self::Live, PairError>> + Send

Pairs the policy with a connected broker, producing the live publisher.

fn channel_bindings(&self, channel: &str) -> Bindings

What a publish through this policy adds to its channel in the generated AsyncAPI document.

fn operation_bindings(&self, channel: &str) -> Bindings

What a publish through this policy adds to its send operation in the document.

fn message_bindings(&self, channel: &str) -> Bindings

What a publish through this policy adds to the messages that leave through it.

fn reply_address_location(&self) -> Option<&'static str>

Where a client finds the address of a reply this policy publishes, as a runtime expression.