mq-bridge-py-basic 0.4.1__tar.gz → 0.4.2__tar.gz

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/Cargo.lock

@@ -3348,7 +3348,7 @@ dependencies = [
 
 [[package]]
 name = "mq-bridge"
-version = "0.4.1"
+version = "0.4.2"
 dependencies = [
  "aes-gcm",
  "anyhow",
@@ -3431,7 +3431,7 @@ dependencies = [
 
 [[package]]
 name = "mq-bridge-bindings-common"
-version = "0.4.1"
+version = "0.4.2"
 dependencies = [
  "anyhow",
  "fast-uuid-v7",
@@ -3445,7 +3445,7 @@ dependencies = [
 
 [[package]]
 name = "mq-bridge-node"
-version = "0.4.1"
+version = "0.4.2"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -3487,7 +3487,7 @@ dependencies = [
 
 [[package]]
 name = "mq-bridge-py"
-version = "0.4.1"
+version = "0.4.2"
 dependencies = [
  "anyhow",
  "async-trait",

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/Cargo.toml

@@ -16,7 +16,7 @@ members = ["bindings-common", "python/mq-bridge-py"]
 resolver = "2"
 
 [workspace.package]
-version = "0.4.1"
+version = "0.4.2"
 
 [workspace.dependencies]
 anyhow = "1.0"

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mq-bridge-py-basic
-Version: 0.4.1
+Version: 0.4.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/docs/ARCHITECTURE.md

@@ -150,6 +150,19 @@ Batch processing is a core concept in mq-bridge and is required for all endpoint
 - Each route can be configured with a `concurrency` parameter, which determines how many worker tasks will process batches in parallel.
 - Batch size is also configurable per route.
 
+#### Ordering
+Two independent guarantees, each decided once per route by the endpoint itself:
+
+- **Commits** follow `MessageConsumer::commit_requires_order()` (default `true`). Cumulative-ack sources such as Kafka funnel their commits through one sequencer; individually-acking sources commit concurrently, bounded by `commit_concurrency_limit`.
+- **Publishing** follows `MessagePublisher::requires_ordered_publish()` (default `false`). Above `concurrency: 1` workers call `send_batch` in parallel, so whole batches can reach the sink out of source order — rows keep their order *within* a batch. The `file` sink declares `true` and the route sequences the `send_batch` calls; batch prep and commits stay parallel, so the ordered path measures within noise of an unordered one.
+
+Only `file` declares it, for two reasons that any other candidate has to clear:
+
+- **The cost must be low.** The file sink already holds a write lock across the whole batch, so sequencing changes who writes, not how many write at once. Sequencing a sink that ends in a network round trip instead costs the whole concurrency factor — one batch in flight instead of N.
+- **The guarantee must be reachable.** `object_store` does *not* declare it: read order there is object-key order, and the uuidv7 key randomises everything below the millisecond, so ordering the writes would buy nothing. Ordered cloud export needs a source-sequenced key first.
+
+Broker sinks keep it off. NATS (both Core and JetStream) publishes a batch through `send_batch_helper`, which keeps up to `SEND_BATCH_CONCURRENCY` publishes in flight, so wire order inside one batch is already unordered — only the results are re-sorted. Kafka and AMQP preserve order within a batch (they submit the whole batch, then await confirms), but for them the order-critical part is the cheap submit loop, not the round trip, so a useful fix would have to release the sequence after submit rather than after `send_batch`. For per-key Kafka ordering today, use `concurrency: 1`.
+
 ### Helper Utilities
 mq-bridge provides several helper functions to make implementing batching easier, especially if your endpoint only supports single-message operations:
 

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/mq-bridge.schema.json

@@ -2972,7 +2972,7 @@
           "minimum": 1
         },
         "concurrency": {
-          "description": "(Optional) Number of concurrent processing tasks for this route. While it improves throughput for high-latency\nhandlers, it adds synchronization overhead for ordered commits and may lead to out-of-order processing\nin the handler. Defaults to 1.",
+          "description": "(Optional) Number of concurrent processing tasks for this route. While it improves throughput for high-latency\nhandlers, it adds synchronization overhead for ordered commits and may lead to out-of-order processing\nin the handler. Above 1, whole batches may also reach the sink out of source order (rows keep their order\nwithin a batch) unless the sink declares itself order-sensitive, as `file` does.\nDefaults to 1.",
           "type": "integer",
           "format": "uint",
           "default": 1,

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/command_handler.rs

@@ -165,6 +165,10 @@ impl MessagePublisher for CommandPublisher {
         self.inner.status().await
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/endpoints/file/mod.rs

@@ -1017,6 +1017,12 @@ impl MessagePublisher for FilePublisher {
         Ok(())
     }
 
+    /// A file is an ordered log by construction: appending batches in the order they
+    /// were read is the whole point of exporting to JSONL/CSV.
+    fn requires_ordered_publish(&self) -> bool {
+        true
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/endpoints/file/tests.rs

@@ -912,6 +912,100 @@ async fn test_file_consumer_subscribe_explicit_no_delete() {
 
 use crate::models::{Endpoint, EndpointType, Route};
 
+// Regression (issue #71): the reporter's repro — 20 numbered rows, file -> file,
+// batch_size 5, concurrency 4 — used to emit whole batches out of source order
+// (e.g. 15..19 first). A file is an ordered log, so `FilePublisher` declares
+// `requires_ordered_publish()` and the route sequences the sends.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_route_file_to_file_preserves_order_at_concurrency() {
+    let dir = tempdir().unwrap();
+    let src = dir.path().join("rows.jsonl");
+    let dst = dir.path().join("out.jsonl");
+    let rows: String = (0..20).map(|i| format!("{i}\n")).collect();
+    tokio::fs::write(&src, rows.as_bytes()).await.unwrap();
+
+    let input = Endpoint::new(EndpointType::File(FileConfig {
+        path: src.to_str().unwrap().to_string(),
+        mode: Some(FileConsumerMode::Consume { delete: false }),
+        format: FileFormat::Raw,
+        ..Default::default()
+    }));
+    let output = Endpoint::new(EndpointType::File(FileConfig {
+        path: dst.to_str().unwrap().to_string(),
+        format: FileFormat::Raw,
+        ..Default::default()
+    }));
+    let route = Route::new(input, output)
+        .with_concurrency(4)
+        .with_batch_size(5)
+        .with_exit_on_empty(true);
+
+    tokio::time::timeout(
+        std::time::Duration::from_secs(10),
+        route.run_until_err("file_order_regression", None, None),
+    )
+    .await
+    .expect("Route should drain and exit")
+    .expect("Route should complete without errors");
+
+    let content = tokio::fs::read_to_string(&dst).await.unwrap();
+    let written: Vec<&str> = content.lines().collect();
+    let expected: Vec<String> = (0..20).map(|i| i.to_string()).collect();
+    assert_eq!(written, expected, "File sink must preserve source order");
+}
+
+// A buffering publisher only returns from `send_batch` once its buffer flushed, so
+// sequencing sends must not let it wait for a batch that is itself waiting to be sent.
+// `max_delay_ms` guarantees the flush, but the interaction is worth pinning: this hangs
+// if the ordered path ever gates on something the sink needs first.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_route_ordered_file_sink_with_buffer_does_not_stall() {
+    use crate::models::{BufferMiddleware, Middleware};
+
+    let dir = tempdir().unwrap();
+    let src = dir.path().join("buf_rows.jsonl");
+    let dst = dir.path().join("buf_out.jsonl");
+    let rows: String = (0..20).map(|i| format!("{i}\n")).collect();
+    tokio::fs::write(&src, rows.as_bytes()).await.unwrap();
+
+    let input = Endpoint::new(EndpointType::File(FileConfig {
+        path: src.to_str().unwrap().to_string(),
+        mode: Some(FileConsumerMode::Consume { delete: false }),
+        format: FileFormat::Raw,
+        ..Default::default()
+    }));
+    let mut output = Endpoint::new(EndpointType::File(FileConfig {
+        path: dst.to_str().unwrap().to_string(),
+        format: FileFormat::Raw,
+        ..Default::default()
+    }));
+    // Buffer larger than one batch, so every flush is timer-driven.
+    output
+        .middlewares
+        .push(Middleware::Buffer(BufferMiddleware {
+            max_messages: 50,
+            max_delay_ms: 20,
+        }));
+
+    let route = Route::new(input, output)
+        .with_concurrency(4)
+        .with_batch_size(5)
+        .with_exit_on_empty(true);
+
+    tokio::time::timeout(
+        std::time::Duration::from_secs(10),
+        route.run_until_err("file_order_buffer", None, None),
+    )
+    .await
+    .expect("Ordered sends through a buffer must not stall")
+    .expect("Route should complete without errors");
+
+    let content = tokio::fs::read_to_string(&dst).await.unwrap();
+    let written: Vec<&str> = content.lines().collect();
+    let expected: Vec<String> = (0..20).map(|i| i.to_string()).collect();
+    assert_eq!(written, expected);
+}
+
 #[tokio::test]
 async fn test_route_file_consume_explicit_delete() {
     let dir = tempdir().unwrap();

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/endpoints/object_store.rs

@@ -9,8 +9,9 @@
 //! - **Sink** ([`ObjectStorePublisher`]): each flushed batch is encoded (reusing the
 //!   file endpoint's [`FileFormat`] codecs) and written as one immutable object at
 //!   `<prefix>/[YYYY/MM/DD/]<uuidv7>.<ext>`. Objects are write-once; nothing is appended
-//!   or mutated. The uuidv7 name sorts by write time; the date prefix is a readability /
-//!   lifecycle-rule convenience only.
+//!   or mutated. The uuidv7 name sorts by write time to *millisecond* granularity only —
+//!   `rand_a`/`rand_b` are random, so objects written within the same millisecond sort in
+//!   arbitrary order. The date prefix is a readability / lifecycle-rule convenience only.
 //! - **Source** ([`ObjectStoreConsumer`]): objects under `prefix` are listed in key order,
 //!   fetched whole, split by `delimiter`, and emitted. Progress is a durable cursor holding
 //!   the last fully-acked object key (via the external checkpoint store), so a restart
@@ -418,6 +419,11 @@ impl MessagePublisher for ObjectStorePublisher {
         Ok(())
     }
 
+    // Deliberately *not* declaring `requires_ordered_publish()`. Unlike the file sink, read
+    // order here is key order, and `next_key` randomises everything below the millisecond, so
+    // sequencing the writes would cost a latency-bound sink its concurrency without buying an
+    // ordering guarantee. Ordered cloud export needs a source-sequenced key first.
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/endpoints/sqlx/mod.rs

@@ -1723,6 +1723,22 @@ fn mysql_data_type_is_any_safe(data_type: &str) -> bool {
     )
 }
 
+/// SQLite declared column types that sqlx maps to a `DataType` the `Any` driver rejects.
+/// sqlx-sqlite parses `sqlite3_column_decltype` with `DataType::from_str`, and only these exact
+/// spellings yield `Bool`/`Date`/`Time`/`Datetime` — everything else either maps to a supported
+/// type or fails to parse and falls back to the runtime value type, which is always safe.
+/// Notably this covers the `DATETIME` columns our own `auto_create_table` DDL emits.
+fn sqlite_decltype_is_any_safe(decl_type: &str) -> bool {
+    !matches!(
+        decl_type,
+        "boolean" | "bool" | "date" | "time" | "datetime" | "timestamp"
+    )
+}
+
+/// Binds are the table name and its schema (`main` unless the name was `schema.table`).
+const SQLITE_COLUMN_TYPES_SQL: &str =
+    "SELECT name AS name, LOWER(type) AS typname FROM pragma_table_info(?, ?) ORDER BY cid";
+
 /// `$1::regclass` resolves the (optionally schema-qualified) table name against the current
 /// search_path. `pg_attribute.attname`/`pg_type.typname` are Postgres `name`-typed columns,
 /// which `Any` cannot decode directly (distinct from `text`), so cast them explicitly.
@@ -1744,8 +1760,10 @@ const MYSQL_COLUMN_TYPES_SQL: &str = "SELECT COLUMN_NAME AS name, LOWER(DATA_TYP
 /// query on the first type it cannot map (`TIMESTAMPTZ` on Postgres, `DECIMAL`/`TIMESTAMP` on
 /// MySQL). We introspect the table's columns and cast every `Any`-incompatible column to a
 /// string type, so the copy succeeds (unmappable values arrive as strings) instead of failing
-/// every read forever. Any introspection failure (or an unsupported driver, e.g. SQLite, whose
-/// dynamic typing needs no cast) falls back to `*`, preserving the previous behaviour.
+/// every read forever. SQLite is affected too: its type info comes from the *declared* type, so
+/// a `DATETIME` column — including the ones `auto_create_table` writes — breaks the read.
+/// Any introspection failure (or an unsupported driver) falls back to `*`, preserving the
+/// previous behaviour.
 async fn build_cursor_projection(pool: &AnyPool, driver_name: &str, table: &str) -> String {
     type SafeFn = fn(&str) -> bool;
     type CastFn = fn(&str) -> String;
@@ -1772,6 +1790,21 @@ async fn build_cursor_projection(pool: &AnyPool, driver_name: &str, table: &str)
                 |ident| format!("CAST({ident} AS CHAR) AS {ident}"),
             )
         }
+        "SQLite" => {
+            let (schema, name) = match table.split_once('.') {
+                Some((s, t)) => (
+                    s.trim_matches('"').to_string(),
+                    t.trim_matches('"').to_string(),
+                ),
+                None => ("main".to_string(), table.trim_matches('"').to_string()),
+            };
+            (
+                SQLITE_COLUMN_TYPES_SQL,
+                vec![name, schema],
+                sqlite_decltype_is_any_safe,
+                |ident| format!("CAST({ident} AS TEXT) AS {ident}"),
+            )
+        }
         _ => return "*".to_string(),
     };
 

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/endpoints/sqlx/tests.rs

@@ -1009,6 +1009,126 @@ async fn test_sqlx_multicolumn_batch() {
     }
 }
 
+// Regression (issue #71): a table written by the publisher with `auto_create_table` must be
+// readable by this library's own cursor reader. The generated DDL declares `locked_until`/
+// `created_at` as DATETIME, which the `Any` driver refuses to decode, so `SELECT *` failed the
+// whole read. The projection now casts those columns to TEXT.
+#[tokio::test]
+async fn test_sqlx_auto_created_table_is_cursor_readable() {
+    sqlx::any::install_default_drivers();
+    let dir = tempdir().unwrap();
+    let path = dir.path().join("roundtrip.db");
+    let url = sqlite_url(&path);
+    drop(tokio::fs::File::create(&path).await.unwrap());
+
+    let config = SqlxConfig {
+        url: url.clone(),
+        table: "orders".to_string(),
+        auto_create_table: true,
+        ..Default::default()
+    };
+    let publisher = SqlxPublisher::new(&config).await.unwrap();
+    publisher
+        .send_batch(
+            (1..=3)
+                .map(|i| CanonicalMessage::new(format!("row{i}").into_bytes(), None))
+                .collect(),
+        )
+        .await
+        .unwrap();
+
+    let read_config = SqlxConfig {
+        url,
+        table: "orders".to_string(),
+        cursor_column: Some("id".to_string()),
+        ..Default::default()
+    };
+    let mut reader = SqlxCursorReader::new(&read_config).await.unwrap();
+    let batch = reader.receive_batch(10).await.unwrap();
+    assert_eq!(batch.messages.len(), 3);
+    let v: serde_json::Value = serde_json::from_slice(&batch.messages[0].payload).unwrap();
+    assert_eq!(v["id"], 1);
+    // The DATETIME columns survive as strings rather than aborting the read. `is_some()`
+    // alone would also pass on a JSON null, which is what a failed cast looks like.
+    assert!(
+        v["created_at"].as_str().is_some(),
+        "got {}",
+        v["created_at"]
+    );
+    assert!(v["locked_until"].is_null());
+}
+
+// A DATETIME cursor column is now readable on SQLite (the projection casts it to TEXT),
+// so the cursor value round-trips as text while `WHERE`/`ORDER BY` still compare the raw
+// column. Pin that resume neither skips nor re-emits rows.
+#[tokio::test]
+async fn test_sqlx_cursor_reader_datetime_cursor_column_resumes() {
+    sqlx::any::install_default_drivers();
+    let dir = tempdir().unwrap();
+    let path = dir.path().join("dtcursor.db");
+    let url = sqlite_url(&path);
+    drop(tokio::fs::File::create(&path).await.unwrap());
+    let pool = AnyPool::connect(&url).await.unwrap();
+    sqlx::query("CREATE TABLE events (id INTEGER PRIMARY KEY, ts DATETIME, note TEXT)")
+        .execute(&pool)
+        .await
+        .unwrap();
+    for (i, ts) in [
+        "2026-08-16 10:00:00",
+        "2026-08-16 10:00:01",
+        "2026-08-16 10:00:02",
+        "2026-08-16 10:00:03",
+    ]
+    .iter()
+    .enumerate()
+    {
+        sqlx::query("INSERT INTO events (id, ts, note) VALUES (?, ?, ?)")
+            .bind((i + 1) as i64)
+            .bind(*ts)
+            .bind(format!("n{i}"))
+            .execute(&pool)
+            .await
+            .unwrap();
+    }
+
+    let config = SqlxConfig {
+        url,
+        table: "events".to_string(),
+        cursor_column: Some("ts".to_string()),
+        cursor_id: Some("dt-1".to_string()),
+        ..Default::default()
+    };
+    let mut reader = SqlxCursorReader::new(&config).await.unwrap();
+    let b1 = reader.receive_batch(2).await.unwrap();
+    assert_eq!(b1.messages.len(), 2);
+    (b1.commit)(vec![MessageDisposition::Ack; 2]).await.unwrap();
+
+    // Resume from the *checkpoint*, not the in-memory cursor: a text-encoded timestamp has
+    // to survive save/load/decode, which reading on through the same reader never exercises.
+    drop(reader);
+    let mut reader = SqlxCursorReader::new(&config).await.unwrap();
+    let b2 = reader.receive_batch(2).await.unwrap();
+    let notes: Vec<String> = b2
+        .messages
+        .iter()
+        .map(|m| {
+            serde_json::from_slice::<serde_json::Value>(&m.payload).unwrap()["note"]
+                .as_str()
+                .unwrap()
+                .to_string()
+        })
+        .collect();
+    assert_eq!(
+        notes,
+        vec!["n2", "n3"],
+        "resume must continue, not repeat or skip"
+    );
+    (b2.commit)(vec![MessageDisposition::Ack; 2]).await.unwrap();
+
+    let b3 = reader.receive_batch(2).await.unwrap();
+    assert!(b3.messages.is_empty(), "drained");
+}
+
 #[tokio::test]
 async fn test_sqlx_auto_create_rejects_tokens() {
     let (_dir, url) = setup_db_file().await;

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/endpoints/structural/fanout.rs

@@ -101,6 +101,11 @@ impl MessagePublisher for FanoutPublisher {
         }
     }
 
+    /// Ordered if any leg is: a fanout is only as order-tolerant as its strictest sink.
+    fn requires_ordered_publish(&self) -> bool {
+        self.publishers.iter().any(|p| p.requires_ordered_publish())
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/endpoints/structural/request.rs

@@ -99,6 +99,10 @@ impl MessagePublisher for RequestForwardPublisher {
         self.request.status().await
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.request.requires_ordered_publish() || self.forward.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/endpoints/structural/switch.rs

@@ -127,6 +127,14 @@ impl MessagePublisher for SwitchPublisher {
         }
     }
 
+    /// Ordered if any branch is: batches for a given branch must stay in source order.
+    fn requires_ordered_publish(&self) -> bool {
+        self.cases
+            .values()
+            .chain(self.default.iter())
+            .any(|p| p.requires_ordered_publish())
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/middleware/buffer.rs

@@ -352,6 +352,10 @@ impl MessagePublisher for BufferPublisher {
         self.core.inner.flush().await
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.core.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/middleware/compression.rs

@@ -87,6 +87,10 @@ impl MessagePublisher for CompressionPublisher {
         }
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/middleware/cookie_jar.rs

@@ -340,6 +340,10 @@ impl MessagePublisher for CookieJarPublisher {
         }
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/middleware/delay.rs

@@ -91,6 +91,10 @@ impl MessagePublisher for DelayPublisher {
         self.inner.send_batch(messages).await
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/middleware/dlq.rs

@@ -311,6 +311,14 @@ impl MessagePublisher for DlqPublisher {
         }
     }
 
+    /// Deliberately follows `inner` only, not the DLQ. An order-sensitive DLQ behind an
+    /// unordered sink would sequence *every* batch — paying the primary sink's whole
+    /// concurrency factor — to order a sparse, failure-only side channel. When the gate
+    /// is on, the DLQ send is inside this `send_batch` and is sequenced with it anyway.
+    fn requires_ordered_publish(&self) -> bool {
+        self.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/middleware/encryption.rs

@@ -90,6 +90,10 @@ impl MessagePublisher for EncryptionPublisher {
         }
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/middleware/limiter.rs

@@ -165,6 +165,10 @@ impl MessagePublisher for LimiterPublisher {
         self.inner.send_batch(messages).await
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/middleware/metrics.rs

@@ -83,6 +83,10 @@ impl MessagePublisher for MetricsPublisher {
         Ok(result)
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/middleware/random_panic.rs

@@ -208,6 +208,10 @@ impl MessagePublisher for RandomPanicPublisher {
         }
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/middleware/retry.rs

@@ -199,6 +199,10 @@ impl MessagePublisher for RetryPublisher {
         }
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/middleware/transform/mod.rs

@@ -134,6 +134,10 @@ impl MessagePublisher for TransformPublisher {
         self.inner.flush().await
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/models.rs

@@ -143,7 +143,9 @@ pub struct RouteOptions {
     pub description: String,
     /// (Optional) Number of concurrent processing tasks for this route. While it improves throughput for high-latency
     /// handlers, it adds synchronization overhead for ordered commits and may lead to out-of-order processing
-    /// in the handler. Defaults to 1.
+    /// in the handler. Above 1, whole batches may also reach the sink out of source order (rows keep their order
+    /// within a batch) unless the sink declares itself order-sensitive, as `file` does.
+    /// Defaults to 1.
     #[serde(default = "default_concurrency")]
     #[cfg_attr(feature = "schema", schemars(range(min = 1)))]
     pub concurrency: usize,

{mq_bridge_py_basic-0.4.1 → mq_bridge_py_basic-0.4.2}/src/plugin/middleware.rs

@@ -359,6 +359,10 @@ impl MessagePublisher for PluginMiddlewarePublisher {
         self.inner.flush().await
     }
 
+    fn requires_ordered_publish(&self) -> bool {
+        self.inner.requires_ordered_publish()
+    }
+
     fn as_any(&self) -> &dyn Any {
         self
     }