Neo4s - scala wrapper for Neo4j. The core ideas were taken from doobie.
libraryDependencies ++= Seq(
"com.nryanov.neo4s" %% "neo4s-core" % "[version]"
)import neo4s._
import neo4s.implicits._
import cats.effect.{ExitCode, IO, IOApp}
import cats.syntax.flatMap._
object BasicSample extends IOApp {
private val NEO4J_URI = "bolt:https://localhost:7687/db/neo4j"
case class Address(street: String)
case class Person(name: String, age: Int, address: Address)
override def run(args: List[String]): IO[ExitCode] = Neo4jTransactor.create[IO](NEO4J_URI).use { transactor =>
val name = "Sherlock Holmes"
val age = 60
val street = "221B Baker Street"
val query = for {
_ <- cypher"create (n:Person {name: $name, age: $age, address: $street})".update.run
person <- cypher"match (n:Person {name: $name}) return n.name, n.age, n.address".query[Person].unique
} yield person
query
.transact(transactor)
.flatTap(returnedName => IO.delay(println(s"Returned person: $returnedName")))
// Returned person: Person(Sherlock Holmes,60,Address(221B Baker Street))
.map(_ => ExitCode.Success)
.handleErrorWith(error => IO.delay(println(s"Error: ${error.getLocalizedMessage}")).map(_ => ExitCode.Error))
}
}As this library is just a wrapper for java driver, all threading management is done by underlying driver.
By default, neo4s provides Get[A] and Put[A] (Meta[A]) for:
- JVM numeric types Byte, Short, Int, Long, Float, and Double;
- BigDecimal and BigInteger;
- Boolean, Char, String, and Array[Byte];
- Date, Time, and Timestamp from the java.sql package;
- LocalDate, LocalTime, LocalDateTime, OffsetTime, OffsetDateTime and ZonedDateTime from the java.time package; and
- List[A], Array[A], Map[String, A]
- single-element case classes wrapping one of the above types.
To derive Get and Put instances for custom type you can use existing Meta[_]:
sealed abstract class Digit(val value: Int)
case object One extends Digit(1)
case object Two extends Digit(2)
case class Another(value: Int) extends Digit(value)
implicit val digitMeta: Meta[Digit] = Meta[Int].imap {
case 1 => One
case 2 => Two
case x => Another(x)
} {
digit => digit.value
}Also, you can do the same but using existing Put/Get:
implicit val digitGet: Get[Digit] = Get[Int].map {
case 1 => One
case 2 => Two
case x => Another(x)
}
implicit val digitPut: Put[Digit] = Put[Int].contramap(digit => digit.value)