Struct AppInfo 

#[non_exhaustive]
pub struct AppInfo {
    pub title: String,
    pub version: String,
    pub description: Option<String>,
    pub id: Option<AppId>,
    pub terms_of_service: Option<String>,
    pub contact: Contact,
    pub license: Option<License>,
    pub tags: Vec<Tag>,
    pub external_docs: Option<ExternalDocs>,
}

Service-level metadata, surfaced to the AsyncAPI generator as the spec Info object.

The title and the version are what a service must state; everything else is optional and reaches the document only when it is filled in.

Examples

use ruststream::runtime::{App, AppInfo, RustStream};
use ruststream::{Contact, License, Tag};

fn app() -> impl App {
    let info = AppInfo::new("payments", "1.4.0")
        .description("everything the payment domain publishes")
        .contact(Contact::new().email("payments@example.com"))
        .license(License::new("Apache-2.0"))
        .tag(Tag::new("payments"));
    RustStream::new(info)
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

title: String

Human-readable service title.

version: String

Service version string.

description: Option<String>

Optional longer description.

id: Option<AppId>

The service’s own identifier, a URI. Emitted as the document’s root id.

terms_of_service: Option<String>

Where the terms of service are published.

contact: Contact

Who to contact about the service.

license: Option<License>

The licence the service is published under.

tags: Vec<Tag>

Labels grouping the service among its neighbours.

external_docs: Option<ExternalDocs>

Where the prose about this service lives.

Implementations

impl AppInfo

pub fn new(title: impl Into<String>, version: impl Into<String>) -> AppInfo

Creates info with a title and version and nothing else.

pub fn description(self, description: impl Into<String>) -> AppInfo

Sets the description.

pub fn id(self, id: AppId) -> AppInfo

Sets the service’s own identifier.

The identifier is a URI, which AppId checks on construction, so the document cannot carry a title where a reader expects an identifier.

Examples

use ruststream::runtime::{App, AppInfo, RustStream};
use ruststream::{AppId, AppIdError};

/// The id comes from the deployment's configuration, so a malformed one fails the build of
/// the app.
fn app(id: &str) -> Result<impl App, AppIdError> {
    let info = AppInfo::new("payments", "1.4.0").id(id.parse::<AppId>()?);
    Ok(RustStream::new(info))
}

pub fn terms_of_service(self, url: impl Into<String>) -> AppInfo

Sets where the terms of service are published.

Examples

use ruststream::runtime::{App, AppInfo, RustStream};

fn app() -> impl App {
    let info =
        AppInfo::new("payments", "1.4.0").terms_of_service("https://example.com/terms");
    RustStream::new(info)
}

pub fn contact(self, contact: Contact) -> AppInfo

Sets who to contact about the service.

Examples

use ruststream::Contact;
use ruststream::runtime::{App, AppInfo, RustStream};

fn app() -> impl App {
    let info =
        AppInfo::new("payments", "1.4.0").contact(Contact::new().name("Payments team"));
    RustStream::new(info)
}

pub fn license(self, license: License) -> AppInfo

Sets the licence the service is published under.

Examples

use ruststream::License;
use ruststream::runtime::{App, AppInfo, RustStream};

fn app() -> impl App {
    let info = AppInfo::new("payments", "1.4.0").license(License::new("MIT"));
    RustStream::new(info)
}

pub fn tag(self, tag: Tag) -> AppInfo

Adds one label to the service. Call repeatedly for several.

Examples

use ruststream::Tag;
use ruststream::runtime::{App, AppInfo, RustStream};

fn app() -> impl App {
    let info = AppInfo::new("payments", "1.4.0")
        .tag(Tag::new("payments"))
        .tag(Tag::new("public"));
    RustStream::new(info)
}

pub fn external_docs(self, docs: ExternalDocs) -> AppInfo

Sets where the prose about this service lives.

Examples

use ruststream::ExternalDocs;
use ruststream::runtime::{App, AppInfo, RustStream};

fn app() -> impl App {
    let info = AppInfo::new("payments", "1.4.0")
        .external_docs(ExternalDocs::new("https://example.com/payments"));
    RustStream::new(info)
}

Trait Implementations

impl Clone for AppInfo

fn clone(&self) -> AppInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AppInfo

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

Formats the value using the given formatter.