feat(core): use internal tagging for Value

That worked better than expected.

Author: gadomski

crates/api/src/item_collection.rs

@@ -3,22 +3,15 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 use stac::{Href, Link, Links};
 
-const ITEM_COLLECTION_TYPE: &str = "FeatureCollection";
-
 /// The return value of the `/items` and `/search` endpoints.
 ///
 /// This might be a [stac::ItemCollection], but if the [fields
 /// extension](https://github.com/stac-api-extensions/fields) is used, it might
 /// not be. Defined by the [itemcollection
 /// fragment](https://github.com/radiantearth/stac-api-spec/blob/main/fragments/itemcollection/README.md).
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
+#[serde(tag = "type", rename = "FeatureCollection")]
 pub struct ItemCollection {
-    #[serde(
-        deserialize_with = "deserialize_type",
-        serialize_with = "serialize_type"
-    )]
-    r#type: String,
-
     /// A possibly-empty array of Item objects.
     #[serde(rename = "features")]
     pub items: Vec<Item>,
@@ -110,7 +103,6 @@ impl ItemCollection {
     pub fn new(items: Vec<Item>) -> Result<ItemCollection> {
         let number_returned = items.len();
         Ok(ItemCollection {
-            r#type: ITEM_COLLECTION_TYPE.to_string(),
             items,
             links: Vec::new(),
             number_matched: None,
@@ -147,25 +139,6 @@ impl Links for ItemCollection {
     }
 }
 
-impl Default for ItemCollection {
-    fn default() -> Self {
-        ItemCollection {
-            r#type: "FeatureCollection".to_string(),
-            items: Vec::new(),
-            links: Vec::new(),
-            number_matched: None,
-            number_returned: None,
-            context: None,
-            additional_fields: Map::default(),
-            next: None,
-            prev: None,
-            first: None,
-            last: None,
-            href: None,
-        }
-    }
-}
-
 impl From<Vec<Item>> for ItemCollection {
     fn from(items: Vec<Item>) -> Self {
         ItemCollection {
@@ -174,17 +147,3 @@ impl From<Vec<Item>> for ItemCollection {
         }
     }
 }
-
-fn deserialize_type<'de, D>(deserializer: D) -> std::result::Result<String, D::Error>
-where
-    D: serde::de::Deserializer<'de>,
-{
-    stac::deserialize_type(deserializer, ITEM_COLLECTION_TYPE)
-}
-
-fn serialize_type<S>(r#type: &String, serializer: S) -> std::result::Result<S::Ok, S::Error>
-where
-    S: serde::ser::Serializer,
-{
-    stac::serialize_type(r#type, serializer, ITEM_COLLECTION_TYPE)
-}

crates/core/CHANGELOG.md

@@ -13,6 +13,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 ### Removed
 
 - Extensions moved to their own crate ([#473](https://github.com/stac-utils/stac-rs/pull/473))
+- `*_TYPE` constants, `deserialize_type` and `serialize_type` top-level functions ([#498](https://github.com/stac-utils/stac-rs/pull/498))
 
 ## [0.10.2] - 2024-10-18
 

crates/core/src/catalog.rs

@@ -2,9 +2,6 @@ use crate::{Error, Fields, Href, Link, Links, Migrate, Result, Version, STAC_VER
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 
-/// The type field for [Catalogs](Catalog).
-pub const CATALOG_TYPE: &str = "Catalog";
-
 /// A STAC Catalog object represents a logical group of other `Catalog`,
 /// [Collection](crate::Collection), and [Item](crate::Item) objects.
 ///
@@ -18,14 +15,8 @@ pub const CATALOG_TYPE: &str = "Catalog";
 /// Their purpose is discovery: to be browsed by people or be crawled by clients
 /// to build a searchable index.
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[serde(tag = "type")]
 pub struct Catalog {
-    /// Set to `"Catalog"` if this Catalog only implements the `Catalog` spec.
-    #[serde(
-        deserialize_with = "deserialize_type",
-        serialize_with = "serialize_type"
-    )]
-    r#type: String,
-
     /// The STAC version the `Catalog` implements.
     #[serde(rename = "stac_version")]
     pub version: Version,
@@ -72,7 +63,6 @@ impl Catalog {
     /// ```
     pub fn new(id: impl ToString, description: impl ToString) -> Catalog {
         Catalog {
-            r#type: CATALOG_TYPE.to_string(),
             version: STAC_VERSION,
             extensions: Vec::new(),
             id: id.to_string(),
@@ -135,20 +125,6 @@ impl Fields for Catalog {
     }
 }
 
-fn deserialize_type<'de, D>(deserializer: D) -> std::result::Result<String, D::Error>
-where
-    D: serde::de::Deserializer<'de>,
-{
-    crate::deserialize_type(deserializer, CATALOG_TYPE)
-}
-
-fn serialize_type<S>(r#type: &String, serializer: S) -> std::result::Result<S::Ok, S::Error>
-where
-    S: serde::ser::Serializer,
-{
-    crate::serialize_type(r#type, serializer, CATALOG_TYPE)
-}
-
 impl Migrate for Catalog {}
 
 #[cfg(test)]
@@ -161,7 +137,6 @@ mod tests {
         let catalog = Catalog::new("an-id", "a description");
         assert!(catalog.title.is_none());
         assert_eq!(catalog.description, "a description");
-        assert_eq!(catalog.r#type, "Catalog");
         assert_eq!(catalog.version, STAC_VERSION);
         assert!(catalog.extensions.is_empty());
         assert_eq!(catalog.id, "an-id");

crates/core/src/collection.rs

@@ -7,9 +7,6 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 use std::collections::HashMap;
 
-/// The type field for [Collections](Collection).
-pub const COLLECTION_TYPE: &str = "Collection";
-
 const DEFAULT_LICENSE: &str = "proprietary";
 
 /// The STAC `Collection` Specification defines a set of common fields to describe
@@ -25,14 +22,8 @@ const DEFAULT_LICENSE: &str = "proprietary";
 /// contains all the required fields is a valid STAC `Collection` and also a valid
 /// STAC `Catalog`.
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[serde(tag = "type")]
 pub struct Collection {
-    /// Must be set to `"Collection"` to be a valid `Collection`.
-    #[serde(
-        deserialize_with = "deserialize_type",
-        serialize_with = "serialize_type"
-    )]
-    r#type: String,
-
     /// The STAC version the `Collection` implements.
     #[serde(rename = "stac_version")]
     pub version: Version,
@@ -173,7 +164,6 @@ impl Collection {
     /// ```
     pub fn new(id: impl ToString, description: impl ToString) -> Collection {
         Collection {
-            r#type: COLLECTION_TYPE.to_string(),
             version: STAC_VERSION,
             extensions: Vec::new(),
             id: id.to_string(),
@@ -418,20 +408,6 @@ impl TryFrom<Map<String, Value>> for Collection {
     }
 }
 
-fn deserialize_type<'de, D>(deserializer: D) -> std::result::Result<String, D::Error>
-where
-    D: serde::de::Deserializer<'de>,
-{
-    crate::deserialize_type(deserializer, COLLECTION_TYPE)
-}
-
-fn serialize_type<S>(r#type: &String, serializer: S) -> std::result::Result<S::Ok, S::Error>
-where
-    S: serde::ser::Serializer,
-{
-    crate::serialize_type(r#type, serializer, COLLECTION_TYPE)
-}
-
 impl Migrate for Collection {}
 
 #[cfg(test)]
@@ -453,7 +429,6 @@ mod tests {
             assert_eq!(collection.extent, Extent::default());
             assert!(collection.summaries.is_none());
             assert!(collection.assets.is_empty());
-            assert_eq!(collection.r#type, "Collection");
             assert_eq!(collection.version, STAC_VERSION);
             assert!(collection.extensions.is_empty());
             assert_eq!(collection.id, "an-id");

crates/core/src/item.rs

@@ -10,9 +10,6 @@ use serde_json::{Map, Value};
 use std::{collections::HashMap, path::Path};
 use url::Url;
 
-/// The type field for [Items](Item).
-pub const ITEM_TYPE: &str = "Feature";
-
 const TOP_LEVEL_ATTRIBUTES: [&str; 8] = [
     "type",
     "stac_extensions",
@@ -32,14 +29,8 @@ const TOP_LEVEL_ATTRIBUTES: [&str; 8] = [
 /// enables any client to search or crawl online catalogs of spatial 'assets'
 /// (e.g., satellite imagery, derived data, DEMs).
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[serde(tag = "type", rename = "Feature")]
 pub struct Item {
-    /// Type of the GeoJSON Object. MUST be set to `"Feature"`.
-    #[serde(
-        deserialize_with = "deserialize_type",
-        serialize_with = "serialize_type"
-    )]
-    r#type: String,
-
     /// The STAC version the `Item` implements.
     #[serde(rename = "stac_version")]
     pub version: Version,
@@ -107,10 +98,8 @@ pub struct Item {
 /// [stac-geoparquet](https://github.com/stac-utils/stac-geoparquet/blob/main/spec/stac-geoparquet-spec.md),
 /// use this "flat" representation.
 #[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "type", rename = "Feature")]
 pub struct FlatItem {
-    #[serde(default = "default_type")]
-    r#type: String,
-
     #[serde(rename = "stac_version", default = "default_stac_version")]
     version: Version,
 
@@ -334,7 +323,6 @@ impl Item {
     /// ```
     pub fn new(id: impl ToString) -> Item {
         Item {
-            r#type: ITEM_TYPE.to_string(),
             version: STAC_VERSION,
             extensions: Vec::new(),
             id: id.to_string(),
@@ -560,7 +548,6 @@ impl Item {
             }
         }
         Ok(FlatItem {
-            r#type: ITEM_TYPE.to_string(),
             version: STAC_VERSION,
             extensions: self.extensions,
             id: self.id,
@@ -677,36 +664,17 @@ impl TryFrom<Item> for Feature {
     }
 }
 
-fn deserialize_type<'de, D>(deserializer: D) -> std::result::Result<String, D::Error>
-where
-    D: serde::de::Deserializer<'de>,
-{
-    crate::deserialize_type(deserializer, ITEM_TYPE)
-}
-
-fn serialize_type<S>(r#type: &String, serializer: S) -> std::result::Result<S::Ok, S::Error>
-where
-    S: serde::ser::Serializer,
-{
-    crate::serialize_type(r#type, serializer, ITEM_TYPE)
-}
-
 fn default_stac_version() -> Version {
     STAC_VERSION
 }
 
-fn default_type() -> String {
-    ITEM_TYPE.to_string()
-}
-
 impl Migrate for Item {}
 
 #[cfg(test)]
 mod tests {
     use super::{Builder, FlatItem, Item};
     use crate::{Asset, STAC_VERSION};
     use geojson::{feature::Id, Feature};
-    use serde_json::Value;
 
     #[test]
     fn new() {
@@ -715,7 +683,6 @@ mod tests {
         assert!(item.properties.datetime.is_some());
         assert!(item.assets.is_empty());
         assert!(item.collection.is_none());
-        assert_eq!(item.r#type, "Feature");
         assert_eq!(item.version, STAC_VERSION);
         assert!(item.extensions.is_empty());
         assert_eq!(item.id, "an-id");
@@ -731,22 +698,6 @@ mod tests {
         assert!(value.get("collection").is_none());
     }
 
-    #[test]
-    fn deserialize_invalid_type_field() {
-        let mut item: Value =
-            serde_json::to_value(crate::read::<Item>("examples/simple-item.json").unwrap())
-                .unwrap();
-        item["type"] = "Item".into(); // must be "Feature"
-        assert!(serde_json::from_value::<Item>(item).is_err());
-    }
-
-    #[test]
-    fn serialize_invalid_type_field() {
-        let mut item = Item::new("an-id");
-        item.r#type = "Item".to_string(); // must be "Feature"
-        assert!(serde_json::to_value(item).is_err());
-    }
-
     #[test]
     #[cfg(feature = "geo")]
     fn set_geometry_sets_bbox() {

crates/core/src/item_collection.rs

@@ -3,13 +3,11 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 use std::{ops::Deref, vec::IntoIter};
 
-/// The type field for [ItemCollections](ItemCollection).
-pub const ITEM_COLLECTION_TYPE: &str = "FeatureCollection";
-
 /// A [GeoJSON FeatureCollection](https://www.rfc-editor.org/rfc/rfc7946#page-12) of items.
 ///
 /// While not part of the STAC specification, ItemCollections are often used to store many items in a single file.
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[serde(tag = "type", rename = "FeatureCollection")]
 pub struct ItemCollection {
     /// The list of [Items](Item).
     ///
@@ -25,23 +23,13 @@ pub struct ItemCollection {
     #[serde(flatten)]
     pub additional_fields: Map<String, Value>,
 
-    /// The type field.
-    ///
-    /// Must be set to "FeatureCollection".
-    #[serde(
-        deserialize_with = "deserialize_type",
-        serialize_with = "serialize_type"
-    )]
-    r#type: String,
-
     #[serde(skip)]
     href: Option<String>,
 }
 
 impl From<Vec<Item>> for ItemCollection {
     fn from(items: Vec<Item>) -> Self {
         ItemCollection {
-            r#type: ITEM_COLLECTION_TYPE.to_string(),
             items,
             links: Vec::new(),
             additional_fields: Map::new(),
@@ -94,20 +82,6 @@ impl Links for ItemCollection {
     }
 }
 
-fn deserialize_type<'de, D>(deserializer: D) -> Result<String, D::Error>
-where
-    D: serde::de::Deserializer<'de>,
-{
-    crate::deserialize_type(deserializer, ITEM_COLLECTION_TYPE)
-}
-
-fn serialize_type<S>(r#type: &String, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: serde::ser::Serializer,
-{
-    crate::serialize_type(r#type, serializer, ITEM_COLLECTION_TYPE)
-}
-
 impl Migrate for ItemCollection {
     fn migrate(mut self, version: &crate::Version) -> crate::Result<Self> {
         let mut items = Vec::with_capacity(self.items.len());