Struct nakadi_types::event_type::EventTypeInput

pub struct EventTypeInput {

    pub name: EventTypeName,
    pub owning_application: OwningApplication,
    pub category: Category,
    pub enrichment_strategies: Vec<EnrichmentStrategy>,
    pub partition_strategy: PartitionStrategy,
    pub partition_key_fields: Option<PartitionKeyFields>,
    pub compatibility_mode: CompatibilityMode,
    pub schema: EventTypeSchemaInput,
    pub cleanup_policy: CleanupPolicy,
    pub default_statistic: Option<EventTypeStatistics>,
    pub options: Option<EventTypeOptions>,
    pub authorization: Option<EventTypeAuthorization>,
    pub audience: Option<EventTypeAudience>,
}

Definition of an event type

This struct is only used for submitting data to Nakadi.

See also Nakadi Manual

Fields

name: EventTypeName

Name of this EventType. The name is constrained by a regular expression.

Note: the name can encode the owner/responsible for this EventType and ideally should follow a common pattern that makes it easy to read and understand, but this level of structure is not enforced. For example a team name and data type can be used such as ‘acme-team.price-change’.

owning_application: OwningApplication

Indicator of the application owning this EventType.

category: Category

Defines the category of this EventType.

The value set will influence, if not set otherwise, the default set of validations, enrichment-strategies, and the effective schema for validation.

enrichment_strategies: Vec<EnrichmentStrategy>

Determines the enrichment to be performed on an Event upon reception. Enrichment is performed once upon reception (and after validation) of an Event and is only possible on fields that are not defined on the incoming Event.

For event types in categories ‘business’ or ‘data’ it’s mandatory to use metadata_enrichment strategy. For ‘undefined’ event types it’s not possible to use this strategy, since metadata field is not required.

See documentation for the write operation for details on behaviour in case of unsuccessful enrichment.

partition_strategy: PartitionStrategy

Determines how the assignment of the event to a partition should be handled.

partition_key_fields: Option<PartitionKeyFields>

Required when ‘partition_resolution_strategy’ is set to ‘hash’. Must be absent otherwise. Indicates the fields used for evaluation the partition of Events of this type.

If this is set it MUST be a valid required field as defined in the schema.

compatibility_mode: CompatibilityMode

Compatibility mode provides a mean for event owners to evolve their schema, given changes respect the semantics defined by this field.

It’s designed to be flexible enough so that producers can evolve their schemas while not inadvertently breaking existent consumers.

Once defined, the compatibility mode is fixed, since otherwise it would break a predefined contract, declared by the producer.

schema: EventTypeSchemaInput

cleanup_policy: CleanupPolicy

Event type cleanup policy. There are two possible values:

default_statistic: Option<EventTypeStatistics>

Operational statistics for an EventType. This data may be provided by users on Event Type creation. Nakadi uses this object in order to provide an optimal number of partitions from a throughput perspective.

options: Option<EventTypeOptions>

authorization: Option<EventTypeAuthorization>

audience: Option<EventTypeAudience>

Implementations

impl EventTypeInput

pub fn builder() -> EventTypeInputBuilder

returns a builder with default values

Trait Implementations

impl Clone for EventTypeInput

fn clone(&self) -> EventTypeInput

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for EventTypeInput

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventTypeInput

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for EventTypeInput

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.