Struct MongoSourceConfig 

pub struct MongoSourceConfig {
    pub connection_uri: String,
    pub database: String,
    pub collection: String,
    pub filter: Option<Value>,
    pub projection: Option<Value>,
    pub sort: Option<Value>,
    pub limit: Option<i64>,
    pub cursor_batch_size: Option<u32>,
    pub batch_size: usize,
}

Available on crate features source-mongodb and source-rest only.

Configuration for the MongoDB source connector.

Example

use faucet_source_mongodb::MongoSourceConfig;
use serde_json::json;

let config = MongoSourceConfig::new(
    "mongodb://localhost:27017",
    "my_database",
    "my_collection",
)
.filter(json!({"status": "active"}))
.projection(json!({"_id": 0, "name": 1, "email": 1}))
.sort(json!({"created_at": -1}))
.limit(1000)
.cursor_batch_size(200)
.with_batch_size(500);

Fields

connection_uri: String

MongoDB connection URI (e.g. mongodb://localhost:27017).

database: String

Database name.

collection: String

Collection name.

filter: Option<Value>

Optional query filter as JSON, converted to a BSON Document at query time.

projection: Option<Value>

Optional field projection as JSON.

sort: Option<Value>

Optional sort specification as JSON.

limit: Option<i64>

Maximum number of documents to return.

cursor_batch_size: Option<u32>

Cursor batch size: documents per server round-trip on the MongoDB driver cursor. This is a wire-level tuning knob — distinct from Self::batch_size, which controls the size of each emitted StreamPage.

batch_size: usize

Records per emitted StreamPage. Documents are pulled from the cursor and yielded whenever the buffer reaches this size. Defaults to DEFAULT_BATCH_SIZE.

batch_size = 0 is the “no batching” sentinel: the cursor is fully drained and the entire result set is emitted in a single page. Useful for small lookup tables or for sinks (e.g. SQL COPY, BigQuery load jobs) that prefer one large request to many small ones.

Implementations

impl MongoSourceConfig

pub fn new( connection_uri: impl Into<String>, database: impl Into<String>, collection: impl Into<String>, ) -> MongoSourceConfig

Create a new config with the required connection URI, database, and collection.

pub fn filter(self, filter: Value) -> MongoSourceConfig

Set the query filter (JSON object converted to BSON at query time).

pub fn projection(self, projection: Value) -> MongoSourceConfig

Set the field projection.

pub fn sort(self, sort: Value) -> MongoSourceConfig

Set the sort specification.

pub fn limit(self, limit: i64) -> MongoSourceConfig

Set the maximum number of documents to return.

pub fn cursor_batch_size(self, cursor_batch_size: u32) -> MongoSourceConfig

Set the MongoDB driver cursor batch size (documents per server round-trip). This is independent of Self::with_batch_size, which controls the size of each emitted StreamPage.

pub fn with_batch_size(self, batch_size: usize) -> MongoSourceConfig

Set the per-page document count for Source::stream_pages.

Pass 0 to opt out of batching — the entire result set is emitted in a single StreamPage.

Trait Implementations

impl Clone for MongoSourceConfig

fn clone(&self) -> MongoSourceConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MongoSourceConfig

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MongoSourceConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for MongoSourceConfig

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for MongoSourceConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.