Extension typeclasses

.github/PULL_REQUEST_TEMPLATE.md

@@ -5,6 +5,7 @@ Brief description of what this PR does, and why it is needed.
 ### Checklist
 
 - [ ] New tests have been added or existing tests have been modified
+- [ ] Changelog updated
 
 ### Notes
 

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ### Added
 
+- Created typeclasses for linking extensions to the items they extend [#85](https://github.com/azavea/stac4s/pull/85)
+
 ### Changed
 
 ### Deprecated

modules/core/src/main/scala/com/azavea/stac4s/ItemCollection.scala

@@ -1,42 +1,73 @@
 package com.azavea.stac4s
 
 import cats.Eq
+import cats.implicits._
 import io.circe._
 import io.circe.refined._
+import io.circe.syntax._
+import shapeless.LabelledGeneric
+import shapeless.ops.record.Keys
 
 final case class ItemCollection(
     _type: String = "FeatureCollection",
     stacVersion: StacVersion,
     stacExtensions: List[String],
     features: List[StacItem],
-    links: List[StacLink]
+    links: List[StacLink],
+    extensionFields: JsonObject = ().asJsonObject
 )
 
 object ItemCollection {
 
+  private val generic      = LabelledGeneric[ItemCollection]
+  private val keys         = Keys[generic.Repr].apply
+  val itemCollectionFields = keys.toList.flatMap(field => substituteFieldName(field.name)).toSet
+
   implicit val eqItemCollection: Eq[ItemCollection] = Eq.fromUniversalEquals
 
-  implicit val encItemCollection: Encoder[ItemCollection] = Encoder.forProduct5(
-    "type",
-    "stac_version",
-    "stac_extensions",
-    "features",
-    "links"
-  )(itemCollection =>
+  implicit val encItemCollection: Encoder[ItemCollection] = new Encoder[ItemCollection] {
+
+    def apply(collection: ItemCollection): Json = {
+      val baseEncoder: Encoder[ItemCollection] = Encoder.forProduct5(
+        "type",
+        "stac_version",
+        "stac_extensions",
+        "features",
+        "links"
+      )(itemCollection =>
+        (
+          itemCollection._type,
+          itemCollection.stacVersion,
+          itemCollection.stacExtensions,
+          itemCollection.features,
+          itemCollection.links
+        )
+      )
+
+      baseEncoder(collection).deepMerge(collection.extensionFields.asJson)
+    }
+  }
+
+  implicit val decItemCollection: Decoder[ItemCollection] = { c: HCursor =>
     (
-      itemCollection._type,
-      itemCollection.stacVersion,
-      itemCollection.stacExtensions,
-      itemCollection.features,
-      itemCollection.links
+      c.get[String]("type"),
+      c.get[StacVersion]("stac_version"),
+      c.get[Option[List[String]]]("stac_extensions"),
+      c.get[List[StacItem]]("features"),
+      c.get[Option[List[StacLink]]]("links"),
+      c.value.as[JsonObject]
+    ).mapN(
+      (
+          _type: String,
+          stacVersion: StacVersion,
+          extensions: Option[List[String]],
+          features: List[StacItem],
+          links: Option[List[StacLink]],
+          document: JsonObject
+      ) =>
+        ItemCollection(_type, stacVersion, extensions getOrElse Nil, features, links getOrElse Nil, document.filter({
+          case (k, _) => !itemCollectionFields.contains(k)
+        }))
     )
-  )
-
-  implicit val decItemCollection: Decoder[ItemCollection] = Decoder.forProduct5(
-    "type",
-    "stac_version",
-    "stac_extensions",
-    "features",
-    "links"
-  )(ItemCollection.apply)
+  }
 }

modules/core/src/main/scala/com/azavea/stac4s/StacCatalog.scala

@@ -1,33 +1,79 @@
 package com.azavea.stac4s
 
 import cats.Eq
+import cats.implicits._
 import io.circe._
+import io.circe.syntax._
+import shapeless.LabelledGeneric
+import shapeless.ops.record.Keys
 
 final case class StacCatalog(
     stacVersion: String,
     stacExtensions: List[String],
     id: String,
     title: Option[String],
     description: String,
-    links: List[StacLink]
+    links: List[StacLink],
+    extensionFields: JsonObject = ().asJsonObject
 )
 
 object StacCatalog {
 
+  private val generic = LabelledGeneric[StacCatalog]
+  private val keys    = Keys[generic.Repr].apply
+  val catalogFields   = keys.toList.flatMap(field => substituteFieldName(field.name)).toSet
+
   implicit val eqStacCatalog: Eq[StacCatalog] = Eq.fromUniversalEquals
 
-  implicit val encCatalog: Encoder[StacCatalog] =
-    Encoder.forProduct6("stac_version", "stac_extensions", "id", "title", "description", "links")(catalog =>
+  implicit val encCatalog: Encoder[StacCatalog] = new Encoder[StacCatalog] {
+
+    def apply(catalog: StacCatalog): Json = {
+      val baseEncoder: Encoder[StacCatalog] =
+        Encoder.forProduct6("stac_version", "stac_extensions", "id", "title", "description", "links")(catalog =>
+          (
+            catalog.stacVersion,
+            catalog.stacExtensions,
+            catalog.id,
+            catalog.title,
+            catalog.description,
+            catalog.links
+          )
+        )
+
+      baseEncoder(catalog).deepMerge(catalog.extensionFields.asJson)
+    }
+  }
+
+  implicit val decCatalog: Decoder[StacCatalog] = { c: HCursor =>
+    (
+      c.get[String]("stac_version"),
+      c.get[List[String]]("stac_extensions"),
+      c.get[String]("id"),
+      c.get[Option[String]]("title"),
+      c.get[String]("description"),
+      c.get[List[StacLink]]("links"),
+      c.value.as[JsonObject]
+    ).mapN(
       (
-        catalog.stacVersion,
-        catalog.stacExtensions,
-        catalog.id,
-        catalog.title,
-        catalog.description,
-        catalog.links
-      )
+          version: String,
+          extensions: List[String],
+          id: String,
+          title: Option[String],
+          description: String,
+          links: List[StacLink],
+          document: JsonObject
+      ) =>
+        StacCatalog.apply(
+          version,
+          extensions,
+          id,
+          title,
+          description,
+          links,
+          document.filter({
+            case (k, _) => !catalogFields.contains(k)
+          })
+        )
     )
-
-  implicit val decCatalog: Decoder[StacCatalog] =
-    Decoder.forProduct6("stac_version", "stac_extensions", "id", "title", "description", "links")(StacCatalog.apply)
+  }
 }

modules/core/src/main/scala/com/azavea/stac4s/StacCollection.scala

@@ -1,8 +1,12 @@
 package com.azavea.stac4s
 
 import cats.Eq
+import cats.implicits._
 import geotrellis.vector.{io => _}
 import io.circe._
+import io.circe.syntax._
+import shapeless.LabelledGeneric
+import shapeless.ops.record.Keys
 
 final case class StacCollection(
     stacVersion: String,
@@ -14,82 +18,105 @@ final case class StacCollection(
     license: StacLicense,
     providers: List[StacProvider],
     extent: StacExtent,
+    summaries: JsonObject,
     properties: JsonObject,
-    links: List[StacLink]
+    links: List[StacLink],
+    extensionFields: JsonObject = ().asJsonObject
 )
 
 object StacCollection {
 
+  private val generic  = LabelledGeneric[StacCollection]
+  private val keys     = Keys[generic.Repr].apply
+  val collectionFields = keys.toList.flatMap(field => substituteFieldName(field.name)).toSet
+
   implicit val eqStacCollection: Eq[StacCollection] = Eq.fromUniversalEquals
 
-  implicit val encoderStacCollection: Encoder[StacCollection] =
-    Encoder.forProduct11(
-      "stac_version",
-      "stac_extensions",
-      "id",
-      "title",
-      "description",
-      "keywords",
-      "license",
-      "providers",
-      "extent",
-      "properties",
-      "links"
-    )(collection =>
-      (
-        collection.stacVersion,
-        collection.stacExtensions,
-        collection.id,
-        collection.title,
-        collection.description,
-        collection.keywords,
-        collection.license,
-        collection.providers,
-        collection.extent,
-        collection.properties,
-        collection.links
+  implicit val encoderStacCollection: Encoder[StacCollection] = new Encoder[StacCollection] {
+
+    def apply(collection: StacCollection): Json = {
+      val baseEncoder: Encoder[StacCollection] = Encoder.forProduct12(
+        "stac_version",
+        "stac_extensions",
+        "id",
+        "title",
+        "description",
+        "keywords",
+        "license",
+        "providers",
+        "extent",
+        "summaries",
+        "properties",
+        "links"
+      )(collection =>
+        (
+          collection.stacVersion,
+          collection.stacExtensions,
+          collection.id,
+          collection.title,
+          collection.description,
+          collection.keywords,
+          collection.license,
+          collection.providers,
+          collection.extent,
+          collection.summaries,
+          collection.properties,
+          collection.links
+        )
       )
-    )
 
-  implicit val decoderStacCollection: Decoder[StacCollection] =
-    Decoder.forProduct11(
-      "stac_version",
-      "stac_extensions",
-      "id",
-      "title",
-      "description",
-      "keywords",
-      "license",
-      "providers",
-      "extent",
-      "properties",
-      "links"
-    )(
+      baseEncoder(collection).deepMerge(collection.extensionFields.asJson)
+    }
+  }
+
+  implicit val decoderStacCollection: Decoder[StacCollection] = { c: HCursor =>
+    (
+      c.get[String]("stac_version"),
+      c.get[Option[List[String]]]("stac_extensions"),
+      c.get[String]("id"),
+      c.get[Option[String]]("title"),
+      c.get[String]("description"),
+      c.get[Option[List[String]]]("keywords"),
+      c.get[StacLicense]("license"),
+      c.get[Option[List[StacProvider]]]("providers"),
+      c.get[StacExtent]("extent"),
+      c.get[Option[JsonObject]]("summaries"),
+      c.get[JsonObject]("properties"),
+      c.get[List[StacLink]]("links"),
+      c.value.as[JsonObject]
+    ).mapN(
       (
           stacVersion: String,
-          stacExtensions: List[String],
+          stacExtensions: Option[List[String]],
           id: String,
           title: Option[String],
           description: String,
           keywords: Option[List[String]],
           license: StacLicense,
           providers: Option[List[StacProvider]],
           extent: StacExtent,
-          properties: Option[JsonObject],
-          links: List[StacLink]
+          summaries: Option[JsonObject],
+          properties: JsonObject,
+          links: List[StacLink],
+          extensionFields: JsonObject
       ) =>
         StacCollection(
           stacVersion,
-          stacExtensions,
+          stacExtensions getOrElse Nil,
           id,
           title,
           description,
           keywords getOrElse List.empty,
           license,
           providers getOrElse List.empty,
           extent,
-          properties getOrElse JsonObject.fromMap(Map.empty),
-          links
+          summaries getOrElse JsonObject.fromMap(Map.empty),
+          properties,
+          links,
+          extensionFields.filter({
+            case (k, _) => !collectionFields.contains(k)
+          })
         )
     )
+  }
 }