Struct MetadataPolicy 

pub struct MetadataPolicy {
    pub required_fields: Vec<RequiredField>,
    pub max_attribute_bytes: Option<usize>,
    pub reject_future_timestamps: bool,
}

Controls which metadata fields must be present and how optional blobs are constrained.

MetadataPolicy provides fine-grained control over metadata validation, allowing you to enforce business rules such as required fields, size limits, and timestamp constraints.

Examples

Strict Policy

use ingest::{MetadataPolicy, RequiredField};

let strict_policy = MetadataPolicy {
    required_fields: vec![
        RequiredField::TenantId,
        RequiredField::DocId,
        RequiredField::ReceivedAt,
        RequiredField::OriginalSource,
    ],
    max_attribute_bytes: Some(1024),
    reject_future_timestamps: true,
};

Lenient Policy

use ingest::MetadataPolicy;

let lenient_policy = MetadataPolicy::default();
// All fields optional, no size limits, future timestamps allowed

Fields

required_fields: Vec<RequiredField>

Metadata fields that must be provided by the caller (after sanitization).

If a required field is missing or empty after control character stripping, ingest fails with IngestError::InvalidMetadata.

Example

use ingest::{MetadataPolicy, RequiredField};

let policy = MetadataPolicy {
    required_fields: vec![RequiredField::TenantId, RequiredField::DocId],
    ..Default::default()
};

Default: empty vector (no required fields)

max_attribute_bytes: Option<usize>

Maximum serialized byte length allowed for metadata.attributes.

If set, the JSON-serialized size of the attributes field must not exceed this limit. This protects downstream systems from very large metadata blobs.

Example

use ingest::MetadataPolicy;

let policy = MetadataPolicy {
    max_attribute_bytes: Some(1024 * 1024), // 1 MB
    ..Default::default()
};

Default: None (unlimited)

reject_future_timestamps: bool

Reject ingests with timestamps that lie in the future.

When true, if received_at is strictly greater than the current time, ingest fails with IngestError::InvalidMetadata containing “future”.

This is useful for detecting clock skew or preventing future-dated content from entering the system.

Default: false

Trait Implementations

impl Clone for MetadataPolicy

fn clone(&self) -> MetadataPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MetadataPolicy

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

Formats the value using the given formatter.

impl Default for MetadataPolicy

fn default() -> MetadataPolicy

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MetadataPolicy

where MetadataPolicy: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for MetadataPolicy

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

where __S: Serializer,

Serialize this value into the given Serde serializer.