Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/medeia/medeia
A BSON libary for scala using typeclasses
https://github.com/medeia/medeia
bson cats codec decoding encoding mongodb scala typeclass typeclass-derivation
Last synced: 2 months ago
JSON representation
A BSON libary for scala using typeclasses
- Host: GitHub
- URL: https://github.com/medeia/medeia
- Owner: medeia
- License: apache-2.0
- Created: 2019-05-21T06:15:08.000Z (over 5 years ago)
- Default Branch: main
- Last Pushed: 2024-09-27T14:34:03.000Z (3 months ago)
- Last Synced: 2024-09-27T17:40:51.898Z (3 months ago)
- Topics: bson, cats, codec, decoding, encoding, mongodb, scala, typeclass, typeclass-derivation
- Language: Scala
- Homepage:
- Size: 404 KB
- Stars: 14
- Watchers: 3
- Forks: 6
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
README
# medeia
[](https://central.sonatype.com/namespace/de.megaera)
[](https://scala-steward.org)
medeia is a BSON library for Scala.
## Goal / Scope
The goal of medeia is to make bson decoding / encoding as easy and fun as JSON decoding / encoding is with circe or argonaut.
medeia includes decoders and encoders for common data structures as well as automatic derivation of decoders and encoders for case classes using shapeless.
## Quickstart
### Add to sbt
```sbt
libraryDependencies += "de.megaera" %% "medeia" % "0.13.1"
```
Currently no complete documentation is present, additional examples(including Scala 3 derives syntax) can be found in the test suites.
If you have questions: don't hesitate to ask via github issues.
### decoding and encoding example:
```scala
import org.mongodb.scala.bson._
import medeia.syntax._
val stringList = List("a", "b")
val encoded = stringList.toBson
// BsonArray{values=[BsonString{value='a'}, BsonString{value='b'}]}
val bsonArray = BsonArray("a", "b")
val decoded = bsonArray.fromBson[List[String]]
// Right(List(a,b)
```
### automatic derivation example for case classes and sealed trait hierarchies:
```scala
import org.mongodb.scala.bson._
import medeia.encoder.BsonEncoder
import medeia.decoder.BsonDecoder
import medeia.codec._
import medeia.syntax._
case class Simple(int: Int, string: Option[String])
implicit val simpleEncoder: BsonEncoder[Simple] = BsonDocumentEncoder.derived
val encoded = Simple(1, Some("a")).toBson
// {"string": "a", "int": 1}
implicit val simpleDecoder: BsonDecoder[Simple] = BsonDocumentDecoder.derived
val doc = BsonDocument("int" -> 1, "string" -> "string")
val decoded = doc.fromBson[Simple]
// Right(Simple(1,Some(string)))
sealed trait Trait
case class Foo(answer: Int) extends Trait
case class Bar(bar: String) extends Trait
implicit val fooCodec: BsonDocumentCodec[Foo] = BsonDocumentCodec.derived
implicit val barCodec: BsonDocumentCodec[Bar] = BsonDocumentCodec.derived
implicit val traitCodec: BsonDocumentCodec[Trait] = BsonDocumentCodec.derived
val encoded = Foo(42).toBson
// {"answer": 42, "type": "Foo"}
```
A transformation function for keynames can be provided as follows:
```scala
import medeia.generic.GenericDerivationOptions
import medeia.encoder.BsonEncoder
import medeia.syntax._
case class Simple(fieldInScala: Int)
implicit val genericDerivationOptions: GenericDerivationOptions[Simple] =
GenericDerivationOptions { case "fieldInScala" => "fieldInBson" }
implicit val simpleEncoder: BsonDocumentEncoder[Simple] = BsonDocumentEncoder.derived
val encoded = Simple(1).toBson
// {"fieldInBson": 1}
```
GenericDerivationOptions works for encoding and decoding.
If the provided partial function is not defined for a key no transformation is used.
### Enumeratum
A separate module exists for encoding and decoding [enumeratum](https://github.com/lloydmeta/enumeratum) enums:
#### Add sbt dependency
```sbt
libraryDependencies += "de.megaera" %% "medeia-enumeratum" % "0.13.1"
```
#### Usage
```scala
import medeia.syntax._
import medeia.enumeratum.Enumeratum
import enumeratum.Enum
import enumeratum.EnumEntry
import scala.collection.immutable
sealed abstract class TestEnum(override val entryName: String) extends EnumEntry
object TestEnum extends Enum[TestEnum] {
override val values: immutable.IndexedSeq[TestEnum] = findValues
case object A extends TestEnum("A")
case object B extends TestEnum("B")
case object C extends TestEnum("C")
implicit val codec: BsonCodec[TestEnum] = Enumeratum.codec(TestEnum)
}
TestEnum.A.toBson
// "A"
```
### Refined
BsonEncoder/BsonDecoder for `eu.timepit:refined` can be found in the `medeia-refined` module
#### Add sbt dependency
```sbt
libraryDependencies += "de.megaera" %% "medeia-refined" % "0.13.1"
```
#### Usage
```scala
import eu.timepit.refined.api.Refined
import eu.timepit.refined.auto._
import eu.timepit.refined.collection._
import medeia.syntax._
import medeia.refined._
val refinedString: String Refined NonEmpty = "test"
refinedString.toBson
// BsonString{value='test'}
```
## License
medeia is licensed under the Apache License, Version 2.0 (the “License”); you may not use this software except in compliance with the License.
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and limitations under the License.