Add readUnsafe to cassandra

macro-quill/src/main/scala/pl/jozwik/quillgeneric/quillmacro/async/AsyncCrudMacro.scala

@@ -137,4 +137,18 @@ class AsyncCrudMacro(val c: MacroContext) extends AbstractAsyncCrudMacro {
     """
   }
 
+  def readUnsafe[K: c.WeakTypeTag, T: c.WeakTypeTag](id: c.Expr[K])(dSchema: c.Expr[_], ex: c.Expr[ExecutionContext]): Tree = {
+    val filter = callFilterOnId[K](id)(dSchema)
+    q"""
+      import ${c.prefix}._
+      val q = $filter
+      for {
+        r <- run(q)
+      } yield {
+        r.headOption
+        .getOrElse(throw new NoSuchElementException(s"$$id"))
+      }
+    """
+  }
+
 }

macro-quill/src/main/scala/pl/jozwik/quillgeneric/quillmacro/async/AsyncCrudWithContext.scala

@@ -50,6 +50,8 @@ trait AsyncCrudWithContext[U] {
 
   def read[K, T <: WithId[K]](id: K)(implicit dSchema: dQuery[T], ex: ExecutionContext): Future[Option[T]] = macro AsyncCrudMacro.read[K, T]
 
+  def readUnsafe[K, T <: WithId[K]](id: K)(implicit dSchema: dQuery[T], ex: ExecutionContext): Future[T] = macro AsyncCrudMacro.readUnsafe[K, T]
+
   def delete[K, T <: WithId[K]](id: K)(implicit dSchema: dQuery[T], ex: ExecutionContext): Future[U] = macro AsyncCrudMacro.delete[K]
 
   def deleteAll[T](implicit dSchema: dQuery[T], ex: ExecutionContext): Future[U] = macro AsyncCrudMacro.deleteAll[T]

macro-quill/src/main/scala/pl/jozwik/quillgeneric/quillmacro/async/AsyncRepository.scala

@@ -34,6 +34,8 @@ trait AsyncBaseRepository[K, T <: WithId[K]] {
 
   def read(id: K)(implicit ex: ExecutionContext): Future[Option[T]]
 
+  def readUnsafe(id: K)(implicit ex: ExecutionContext): Future[T]
+
   def update(t: T)(implicit ex: ExecutionContext): Future[U]
 
   def updateAndRead(t: T)(implicit ex: ExecutionContext): Future[T]

quill-cassandra-macro/src/test/scala/pl/jozwik/quillgeneric/cassandra/async/AddressSuite.scala

@@ -1,11 +1,11 @@
 package pl.jozwik.quillgeneric.cassandra.async
 
-import pl.jozwik.quillgeneric.cassandra.async.repository.AddressAsyncRepository
+import pl.jozwik.quillgeneric.cassandra.async.repository.AddressRepositoryGen
 import pl.jozwik.quillgeneric.cassandra.model.AddressId
 
 trait AddressSuite extends AbstractAsyncSpec {
 
-  private lazy val repository = new AddressAsyncRepository(ctx)
+  private lazy val repository = new AddressRepositoryGen(ctx)
 
   "AddressSuite simple transformation" should {
 
@@ -17,6 +17,7 @@ trait AddressSuite extends AbstractAsyncSpec {
         val all = repository.all.futureValue
         logger.debug(s"$all")
         repository.read(id).futureValue shouldBe Option(address)
+        repository.readUnsafe(id).futureValue shouldBe address
         repository.all.futureValue shouldBe Seq(address)
         repository.deleteAll.futureValue
         repository.all.futureValue shouldBe Seq.empty

quill-cassandra-macro/src/test/scala/pl/jozwik/quillgeneric/cassandra/async/repository/AddressAsyncRepository.scala → quill-cassandra-macro/src/test/scala/pl/jozwik/quillgeneric/cassandra/async/repository/AddressRepositoryGen.scala

@@ -7,46 +7,49 @@ import pl.jozwik.quillgeneric.quillmacro.cassandra.async.CassandraAsyncRepositor
 
 import scala.concurrent.{ ExecutionContext, Future }
 
-final class AddressAsyncRepository[Naming <: NamingStrategy](
+final class AddressRepositoryGen[Naming <: NamingStrategy](
     protected val context: CassandraAsyncContextDateQuotes[Naming],
     protected val tableName: String = "Address"
 ) extends CassandraAsyncRepository[AddressId, Address, Naming] {
 
   protected def dynamicSchema: context.DynamicEntityQuery[Address] = dSchema
 
   private implicit val dSchema: context.DynamicEntityQuery[Address] = {
-    import context._
-    context.dynamicQuerySchema[Address](tableName, alias(_.city, "city"))
+
+    context.dynamicQuerySchema[Address](tableName)
   }
 
   override def all(implicit ec: ExecutionContext): Future[Seq[Address]] =
-    context.all[Address]
+    context.all[Address](dSchema, ec)
 
   override def create(entity: Address)(implicit ec: ExecutionContext): Future[AddressId] =
-    context.create[AddressId, Address](entity)
+    context.create[AddressId, Address](entity)(dSchema, ec)
 
   override def createAndRead(entity: Address)(implicit ec: ExecutionContext): Future[Address] =
     context.createAndRead[AddressId, Address](entity)
 
-  override def read(id: AddressId)(implicit ec: ExecutionContext): Future[Option[Address]] =
-    context.read[AddressId, Address](id)
-
   override def createOrUpdate(entity: Address)(implicit ec: ExecutionContext): Future[AddressId] =
     context.create[AddressId, Address](entity)
 
   override def createOrUpdateAndRead(entity: Address)(implicit ec: ExecutionContext): Future[Address] =
     context.createAndRead[AddressId, Address](entity)
 
+  override def read(id: AddressId)(implicit ec: ExecutionContext): Future[Option[Address]] =
+    context.read[AddressId, Address](id)(dSchema, ec)
+
+  override def readUnsafe(id: AddressId)(implicit ec: ExecutionContext): Future[Address] =
+    context.readUnsafe[AddressId, Address](id)(dSchema, ec)
+
   override def update(entity: Address)(implicit ec: ExecutionContext): Future[Unit] =
-    context.update[AddressId, Address](entity)
+    context.update[AddressId, Address](entity)(dSchema, ec)
 
   override def updateAndRead(entity: Address)(implicit ec: ExecutionContext): Future[Address] =
     context.updateAndRead[AddressId, Address](entity)
 
   override def delete(id: AddressId)(implicit ec: ExecutionContext): Future[Unit] =
-    context.delete[AddressId, Address](id)
+    context.delete[AddressId, Address](id)(dSchema, ec)
 
   override def deleteAll(implicit ec: ExecutionContext): Future[Unit] =
-    context.deleteAll
+    context.deleteAll(dSchema, ec)
 
 }

quill-jdbc-macro/src/test/scala/pl/jozwik/quillgeneric/async/jdbc/repository/ConfigurationAsyncRepository.scala

@@ -43,6 +43,9 @@ class ConfigurationAsyncRepository[D <: SqlIdiom, N <: NamingStrategy, C <: Conn
   override def read(id: ConfigurationId)(implicit ex: ExecutionContext): Future[Option[Configuration]] =
     context.read[ConfigurationId, Configuration](id)
 
+  override def readUnsafe(id: ConfigurationId)(implicit ex: ExecutionContext): Future[Configuration] =
+    context.readUnsafe[ConfigurationId, Configuration](id)
+
   override def update(t: Configuration)(implicit ex: ExecutionContext): Future[U] =
     context.update[ConfigurationId, Configuration](t)
 

quill-jdbc-macro/src/test/scala/pl/jozwik/quillgeneric/async/jdbc/repository/PersonAsyncRepository.scala

@@ -61,6 +61,9 @@ class PersonAsyncRepository[D <: SqlIdiom, N <: NamingStrategy, C <: Connection]
   override def read(id: PersonId)(implicit ex: ExecutionContext): Future[Option[Person]] =
     context.read[PersonId, Person](id)
 
+  override def readUnsafe(id: PersonId)(implicit ex: ExecutionContext): Future[Person] =
+    context.readUnsafe[PersonId, Person](id)
+
   override def update(t: Person)(implicit ex: ExecutionContext): Future[U] =
     context.update[PersonId, Person](t)
 

version.sbt

@@ -1 +1 @@
-ThisBuild / version := "0.8.1"
+ThisBuild / version := "0.8.2"