Merge branch 'main' into client-traits

Author: gadomski

Cargo.toml

@@ -66,7 +66,7 @@ geojson = "0.24.1"
 getrandom = { version = "0.4.0", features = ["wasm_js"] }
 http = "1.1"
 indexmap = { version = "2.10.0", features = ["serde"] }
-jsonschema = { version = "0.41.0", default-features = false, features = [
+jsonschema = { version = "0.42.0", default-features = false, features = [
     "resolve-async",
 ] }
 libduckdb-sys = "1.3.0"
@@ -77,7 +77,7 @@ object_store = "0.12.0"
 parquet = { version = "56.0.0" }
 quote = "1.0"
 reqwest = { version = "0.13.1", features = ["query"] }
-referencing = { version = "0.41.0", features = ["retrieve-async"] }
+referencing = { version = "0.42.0", features = ["retrieve-async"] }
 rstest = "0.26.1"
 rustls = "0.23.22"
 serde = "1.0"

crates/cli/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.7](https://github.com/stac-utils/rustac/compare/rustac-v0.2.6...rustac-v0.2.7) - 2026-02-12
+
+### Other
+
+- updated the following local packages: stac, stac-io, stac-validate, pgstac, stac-duckdb, stac-server
+
 ## [0.2.6](https://github.com/stac-utils/rustac/compare/rustac-v0.2.5...rustac-v0.2.6) - 2026-02-03
 
 ### Added

crates/cli/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "rustac"
 description = "Command line interface for rustac"
-version = "0.2.6"
+version = "0.2.7"
 keywords = ["geospatial", "stac", "metadata", "geo", "raster"]
 authors.workspace = true
 edition.workspace = true
@@ -24,16 +24,16 @@ clap = { workspace = true, features = ["derive"] }
 clap_complete.workspace = true
 futures-core.workspace = true
 futures-util.workspace = true
-pgstac = { version = "0.4.5", path = "../pgstac", optional = true }
+pgstac = { version = "0.4.6", path = "../pgstac", optional = true }
 serde_json.workspace = true
-stac = { version = "0.16.2", path = "../core" }
-stac-duckdb = { version = "0.3.4", path = "../duckdb" }
-stac-io = { version = "0.2.4", path = "../io", features = [
+stac = { version = "0.16.3", path = "../core" }
+stac-duckdb = { version = "0.3.5", path = "../duckdb" }
+stac-io = { version = "0.2.5", path = "../io", features = [
     "store-all",
     "geoparquet",
 ] }
-stac-server = { version = "0.4.5", path = "../server", features = ["axum", "duckdb"] }
-stac-validate = { version = "0.6.4", path = "../validate" }
+stac-server = { version = "0.4.6", path = "../server", features = ["axum", "duckdb"] }
+stac-validate = { version = "0.6.5", path = "../validate" }
 tokio = { workspace = true, features = [
     "macros",
     "io-std",

crates/cli/src/lib.rs

@@ -382,19 +382,30 @@ impl Rustac {
                 migrate,
                 ref to,
             } => {
-                let mut value = self.get(infile.as_deref()).await?;
                 if migrate {
+                    let mut value = self.get(infile.as_deref()).await?;
                     value = value.migrate(
                         &to.as_deref()
                             .map(|s| s.parse().unwrap())
                             .unwrap_or_default(),
                     )?;
-                } else if let Some(to) = to {
-                    eprintln!(
-                        "WARNING: --to was passed ({to}) without --migrate, value will not be migrated"
-                    );
+                    self.put(outfile.as_deref(), value.into()).await
+                } else {
+                    if let Some(to) = to {
+                        eprintln!(
+                            "WARNING: --to was passed ({to}) without --migrate, value will not be migrated"
+                        );
+                    }
+                    let input_format = self.input_format(infile.as_deref());
+                    let can_stream = matches!(input_format, Format::NdJson | Format::Geoparquet(_));
+                    if can_stream {
+                        let items = self.get_item_stream(infile.as_deref()).await?;
+                        self.put_item_stream(outfile.as_deref(), items).await
+                    } else {
+                        let value = self.get(infile.as_deref()).await?;
+                        self.put(outfile.as_deref(), value.into()).await
+                    }
                 }
-                self.put(outfile.as_deref(), value.into()).await
             }
             Command::Search {
                 ref href,
@@ -681,6 +692,41 @@ impl Rustac {
         }
     }
 
+    async fn get_item_stream(
+        &self,
+        href: Option<&str>,
+    ) -> Result<Box<dyn Iterator<Item = Result<Item>> + Send>> {
+        let href = href.and_then(|s| if s == "-" { None } else { Some(s) });
+        let format = self.input_format(href);
+        if let Some(href) = href {
+            let (store, path) = stac_io::parse_href_opts(href, self.opts())?;
+            let iter = store.get_item_stream(path, format).await?;
+            Ok(Box::new(iter.map(|r| r.map_err(Error::from))))
+        } else {
+            let mut buf = Vec::new();
+            let _ = tokio::io::stdin().read_to_end(&mut buf).await?;
+            match format {
+                Format::NdJson => {
+                    let cursor = std::io::BufReader::new(std::io::Cursor::new(buf));
+                    Ok(Box::new(
+                        stac_io::ndjson_item_reader(cursor).map(|r| r.map_err(Error::from)),
+                    ))
+                }
+                _ => {
+                    let value: stac::Value = format.from_bytes(buf)?;
+                    let items = match value {
+                        stac::Value::Item(item) => vec![item],
+                        stac::Value::ItemCollection(ic) => ic.items,
+                        other => {
+                            return Err(anyhow!("cannot stream items from {}", other.type_name()));
+                        }
+                    };
+                    Ok(Box::new(items.into_iter().map(Ok)))
+                }
+            }
+        }
+    }
+
     async fn put(&self, href: Option<&str>, value: Value) -> Result<()> {
         let href = href.and_then(|s| if s == "-" { None } else { Some(s) });
         let format = self.output_format(href);
@@ -705,6 +751,46 @@ impl Rustac {
         }
     }
 
+    async fn put_item_stream(
+        &self,
+        href: Option<&str>,
+        items: impl Iterator<Item = Result<Item>>,
+    ) -> Result<()> {
+        let href = href.and_then(|s| if s == "-" { None } else { Some(s) });
+        let format = self.output_format(href);
+        if let Some(href) = href {
+            let (store, path) = stac_io::parse_href_opts(href, self.opts())?;
+            let items: Vec<Item> = items.collect::<Result<Vec<_>>>()?;
+            store
+                .put_item_stream(path, items.into_iter(), format)
+                .await?;
+            Ok(())
+        } else {
+            match format {
+                Format::NdJson => {
+                    let stdout = std::io::stdout();
+                    let mut writer = std::io::BufWriter::new(stdout.lock());
+                    for item in items {
+                        let item = item?;
+                        serde_json::to_writer(&mut writer, &item)?;
+                        writeln!(&mut writer)?;
+                    }
+                    Ok(())
+                }
+                _ => {
+                    let items: Vec<Item> = items.collect::<Result<Vec<_>>>()?;
+                    let item_collection = stac::ItemCollection::from(items);
+                    let mut bytes = format.into_vec(item_collection)?;
+                    if !matches!(format, Format::NdJson) {
+                        bytes.push(b'\n');
+                    }
+                    std::io::stdout().write_all(&bytes)?;
+                    Ok(())
+                }
+            }
+        }
+    }
+
     pub fn log_level(&self) -> Option<Level> {
         level_enum(self.verbosity())
     }

crates/core/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.16.3](https://github.com/stac-utils/rustac/compare/stac-v0.16.2...stac-v0.16.3) - 2026-02-12
+
+### Fixed
+
+- windows paths ([#955](https://github.com/stac-utils/rustac/pull/955))
+
 ## [0.16.2](https://github.com/stac-utils/rustac/compare/stac-v0.16.1...stac-v0.16.2) - 2026-02-03
 
 ### Other

crates/core/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "stac"
 description = "Rust library for the SpatioTemporal Asset Catalog (STAC) specification"
-version = "0.16.2"
+version = "0.16.3"
 keywords = ["geospatial", "stac", "metadata", "geo"]
 authors.workspace = true
 categories.workspace = true

crates/core/src/error.rs

@@ -58,6 +58,10 @@ pub enum Error {
     #[error("invalid datetime: {0}")]
     InvalidDatetime(String),
 
+    /// A file path could not be converted to a URL.
+    #[error("invalid file path: {0}")]
+    InvalidFilePath(String),
+
     /// [std::io::Error]
     #[error(transparent)]
     Io(#[from] std::io::Error),

crates/core/src/geoarrow/json.rs

@@ -517,7 +517,7 @@ pub fn from_record_batch_reader<R: RecordBatchReader>(
     Ok(rows)
 }
 
-fn record_batch_to_json_rows(
+pub(crate) fn record_batch_to_json_rows(
     record_batch: RecordBatch,
 ) -> Result<Vec<JsonMap<String, Value>>, Error> {
     let mut rows: Vec<Option<JsonMap<String, Value>>> =

crates/core/src/geoarrow/mod.rs

@@ -257,6 +257,27 @@ fn iter_items(
     })
 }
 
+/// Converts a single [RecordBatch] to a vector of [Item]s.
+///
+/// # Examples
+///
+/// ```
+/// use stac::{Item, geoarrow};
+/// use geojson::{Geometry, Value};
+///
+/// let mut item = Item::new("an-id");
+/// item.geometry = Some(Geometry::new(Value::Point(vec![-105.1, 41.1])));
+/// let (record_batch, _) = geoarrow::encode(vec![item]).unwrap();
+/// let items = geoarrow::items_from_record_batch(record_batch).unwrap();
+/// assert_eq!(items.len(), 1);
+/// ```
+pub fn items_from_record_batch(record_batch: RecordBatch) -> Result<Vec<Item>> {
+    json::record_batch_to_json_rows(record_batch)?
+        .into_iter()
+        .map(|item| serde_json::from_value(Value::Object(item)).map_err(Error::from))
+        .collect()
+}
+
 /// Converts a [RecordBatchReader] to an [ItemCollection].
 ///
 /// # Examples

crates/core/src/geoparquet.rs

@@ -129,6 +129,43 @@ where
     crate::geoarrow::from_record_batch_reader(reader)
 }
 
+/// Returns an iterator that yields batches of [Item]s from a [ChunkReader].
+///
+/// Unlike [from_reader], this does not collect all items into memory at once.
+/// Each iteration yields one record batch worth of items.
+///
+/// # Examples
+///
+/// ```
+/// use std::fs::File;
+///
+/// let file = File::open("data/extended-item.parquet").unwrap();
+/// let mut count = 0;
+/// for result in stac::geoparquet::from_reader_iter(file).unwrap() {
+///     let items = result.unwrap();
+///     count += items.len();
+/// }
+/// assert!(count > 0);
+/// ```
+pub fn from_reader_iter<R>(reader: R) -> Result<impl Iterator<Item = Result<Vec<Item>>>>
+where
+    R: ChunkReader + 'static,
+{
+    let builder = ParquetRecordBatchReaderBuilder::try_new(reader)?;
+    let geoparquet_metadata = builder
+        .geoparquet_metadata()
+        .transpose()?
+        .ok_or(Error::MissingGeoparquetMetadata)?;
+    let geoarrow_schema =
+        builder.geoarrow_schema(&geoparquet_metadata, true, Default::default())?;
+    let reader = builder.build()?;
+    let reader = GeoParquetRecordBatchReader::try_new(reader, geoarrow_schema)?;
+    Ok(reader.map(|result| {
+        let record_batch = result?;
+        crate::geoarrow::items_from_record_batch(record_batch)
+    }))
+}
+
 /// Writes a [ItemCollection] to a [std::io::Write] as
 /// [stac-geoparquet](https://github.com/stac-utils/stac-geoparquet).
 ///