Convert source record

modules/restserver/src/main/scala/docspell/restserver/routes/ItemRoutes.scala

@@ -1,17 +1,17 @@
 package docspell.restserver.routes
 
+import cats.Monoid
 import cats.data.NonEmptyList
 import cats.effect._
 import cats.implicits._
-import cats.Monoid
 
 import docspell.backend.BackendApp
 import docspell.backend.auth.AuthToken
 import docspell.backend.ops.OCustomFields.{RemoveValue, SetValue}
 import docspell.backend.ops.OFulltext
 import docspell.backend.ops.OItemSearch.Batch
-import docspell.common.syntax.all._
 import docspell.common._
+import docspell.common.syntax.all._
 import docspell.restapi.model._
 import docspell.restserver.Config
 import docspell.restserver.conv.Conversions

modules/store/src/main/scala/docspell/store/records/RSource.scala

@@ -1,8 +1,8 @@
 package docspell.store.records
 
 import docspell.common._
-import docspell.store.impl.Implicits._
+import docspell.store.qb.DSL._
-import docspell.store.impl._
+import docspell.store.qb._
 
 import doobie._
 import doobie.implicits._
@@ -26,20 +26,19 @@ case class RSource(
 
 object RSource {
 
-  val table = fr"source"
+  final case class Table(alias: Option[String]) extends TableDef {
+    val tableName = "source"
 
-  object Columns {
+    val sid         = Column[Ident]("sid", this)
-
+    val cid         = Column[Ident]("cid", this)
-    val sid         = Column("sid")
+    val abbrev      = Column[String]("abbrev", this)
-    val cid         = Column("cid")
+    val description = Column[String]("description", this)
-    val abbrev      = Column("abbrev")
+    val counter     = Column[Int]("counter", this)
-    val description = Column("description")
+    val enabled     = Column[Boolean]("enabled", this)
-    val counter     = Column("counter")
+    val priority    = Column[Priority]("priority", this)
-    val enabled     = Column("enabled")
+    val created     = Column[Timestamp]("created", this)
-    val priority    = Column("priority")
+    val folder      = Column[Ident]("folder_id", this)
-    val created     = Column("created")
+    val fileFilter  = Column[Glob]("file_filter", this)
-    val folder      = Column("folder_id")
-    val fileFilter  = Column("file_filter")
 
     val all =
       List(
@@ -56,48 +55,54 @@ object RSource {
       )
   }
 
-  import Columns._
+  def as(alias: String): Table =
+    Table(Some(alias))
+
+  val table = Table(None)
 
   def insert(v: RSource): ConnectionIO[Int] = {
-    val sql = insertRow(
+    val sql = DML.insert(
       table,
-      all,
+      table.all,
       fr"${v.sid},${v.cid},${v.abbrev},${v.description},${v.counter},${v.enabled},${v.priority},${v.created},${v.folderId},${v.fileFilter}"
     )
     sql.update.run
   }
 
-  def updateNoCounter(v: RSource): ConnectionIO[Int] = {
+  def updateNoCounter(v: RSource): ConnectionIO[Int] =
-    val sql = updateRow(
+    DML.update(
       table,
-      and(sid.is(v.sid), cid.is(v.cid)),
+      where(table.sid === v.sid, table.cid === v.cid),
-      commas(
+      DML.set(
-        cid.setTo(v.cid),
+        table.cid.setTo(v.cid),
-        abbrev.setTo(v.abbrev),
+        table.abbrev.setTo(v.abbrev),
-        description.setTo(v.description),
+        table.description.setTo(v.description),
-        enabled.setTo(v.enabled),
+        table.enabled.setTo(v.enabled),
-        priority.setTo(v.priority),
+        table.priority.setTo(v.priority),
-        folder.setTo(v.folderId),
+        table.folder.setTo(v.folderId),
-        fileFilter.setTo(v.fileFilter)
+        table.fileFilter.setTo(v.fileFilter)
       )
     )
-    sql.update.run
-  }
 
   def incrementCounter(source: String, coll: Ident): ConnectionIO[Int] =
-    updateRow(
+    DML
-      table,
+      .update(
-      and(abbrev.is(source), cid.is(coll)),
+        table,
-      counter.f ++ fr"=" ++ counter.f ++ fr"+ 1"
+        where(table.abbrev === source, table.cid === coll),
-    ).update.run
+        DML.set(table.counter.increment(1))
+      )
 
   def existsById(id: Ident): ConnectionIO[Boolean] = {
-    val sql = selectCount(sid, table, sid.is(id))
+    val sql = run(select(count(table.sid)), from(table), where(table.sid === id))
     sql.query[Int].unique.map(_ > 0)
   }
 
   def existsByAbbrev(coll: Ident, abb: String): ConnectionIO[Boolean] = {
-    val sql = selectCount(sid, table, and(cid.is(coll), abbrev.is(abb)))
+    val sql = run(
+      select(count(table.sid)),
+      from(table),
+      where(table.cid === coll, table.abbrev === abb)
+    )
     sql.query[Int].unique.map(_ > 0)
   }
 
@@ -105,25 +110,34 @@ object RSource {
     findEnabledSql(id).query[RSource].option
 
   private[records] def findEnabledSql(id: Ident): Fragment =
-    selectSimple(all, table, and(sid.is(id), enabled.is(true)))
+    run(select(table.all), from(table), where(table.sid === id, table.enabled === true))
 
   def findCollective(sourceId: Ident): ConnectionIO[Option[Ident]] =
-    selectSimple(List(cid), table, sid.is(sourceId)).query[Ident].option
+    run(select(table.cid), from(table), table.sid === sourceId).query[Ident].option
 
   def findAll(
       coll: Ident,
-      order: Columns.type => Column
+      order: Table => Column[_]
   ): ConnectionIO[Vector[RSource]] =
     findAllSql(coll, order).query[RSource].to[Vector]
 
-  private[records] def findAllSql(coll: Ident, order: Columns.type => Column): Fragment =
+  private[records] def findAllSql(
-    selectSimple(all, table, cid.is(coll)) ++ orderBy(order(Columns).f)
+      coll: Ident,
+      order: Table => Column[_]
+  ): Fragment = {
+    val t = RSource.as("s")
+    Select(select(t.all), from(t), t.cid === coll).orderBy(order(t)).run
+  }
 
   def delete(sourceId: Ident, coll: Ident): ConnectionIO[Int] =
-    deleteFrom(table, and(sid.is(sourceId), cid.is(coll))).update.run
+    DML.delete(table, where(table.sid === sourceId, table.cid === coll)).update.run
 
   def removeFolder(folderId: Ident): ConnectionIO[Int] = {
     val empty: Option[Ident] = None
-    updateRow(table, folder.is(folderId), folder.setTo(empty)).update.run
+    DML.update(
+      table,
+      where(table.folder === folderId),
+      DML.set(table.folder.setTo(empty))
+    )
   }
 }

modules/store/src/main/scala/docspell/store/records/SourceData.scala

@@ -5,8 +5,8 @@ import cats.implicits._
 import fs2.Stream
 
 import docspell.common._
-import docspell.store.impl.Implicits._
+import docspell.store.impl.DoobieMeta._
-import docspell.store.impl._
+import docspell.store.qb._
 
 import doobie._
 import doobie.implicits._
@@ -22,7 +22,7 @@ object SourceData {
 
   def findAll(
       coll: Ident,
-      order: RSource.Columns.type => Column
+      order: RSource.Table => Column[_]
   ): Stream[ConnectionIO, SourceData] =
     findAllWithTags(RSource.findAllSql(coll, order).query[RSource].stream)
 

modules/store/src/test/scala/docspell/store/qb/QueryBuilderTest.scala

@@ -1,6 +1,7 @@
 package docspell.store.qb
 
 import minitest._
+import docspell.store.qb._
 import docspell.store.qb.model._
 import docspell.store.qb.DSL._
 
@@ -28,10 +29,37 @@ object QueryBuilderTest extends SimpleTestSuite {
         )
       )
 
-    // val order =
+    val q = Select(proj, tables, cond).orderBy(c.name.desc)
-    //   orderBy(c.name.asc)
+    q match {
-
+      case Select.Ordered(Select.SimpleSelect(proj, from, where, group), sb, vempty) =>
-    val q = Select(proj, tables, cond)
+        assert(vempty.isEmpty)
-    println(q)
+        assertEquals(sb, OrderBy(SelectExpr.SelectColumn(c.name), OrderBy.OrderType.Desc))
+        assertEquals(11, proj.size)
+        from match {
+          case FromExpr.From(_) =>
+            fail("Unexpected from value")
+          case FromExpr.Joined(f, joins) =>
+            assertEquals(f, FromExpr.From(c))
+            assertEquals(2, joins.size)
+            joins.head match {
+              case Join.InnerJoin(tbl, cond) =>
+                assertEquals(tbl, owner)
+                assertEquals(cond, c.ownerId === owner.id)
+              case _ =>
+                fail("Unexpected join result")
+            }
+            joins.tail.head match {
+              case Join.LeftJoin(tbl, cond) =>
+                assertEquals(tbl, lecturer)
+                assertEquals(cond, c.lecturerId === lecturer.id)
+              case _ =>
+                fail("Unexpected join result")
+            }
+        }
+        assertEquals(group, None)
+        assert(where.isDefined)
+      case _ =>
+        fail("Unexpected case")
+    }
   }
 }

modules/store/src/test/scala/docspell/store/qb/impl/DoobieQueryTest.scala

@@ -4,7 +4,6 @@ import minitest._
 import docspell.store.qb._
 import docspell.store.qb.model._
 import docspell.store.qb.DSL._
-import docspell.common._
 
 object DoobieQueryTest extends SimpleTestSuite {
 
@@ -23,28 +22,11 @@ object DoobieQueryTest extends SimpleTestSuite {
     )
 
     val q    = Select(proj, table, cond)
-    val frag = DoobieQuery.select(q)
+    val frag = DoobieQuery(q)
     assertEquals(
       frag.toString,
       """Fragment("SELECT c.id, c.name, c.owner_id, c.lecturer_id, c.lessons FROM course c INNER JOIN person o ON c.owner_id = o.id LEFT JOIN person l ON c.lecturer_id = l.id WHERE (LOWER(c.name) LIKE ? AND o.name = ? )")"""
     )
   }
 
-  test("basic update") {
-    val p = PersonRecord.table
-
-    val update = PersonRecord.update(p.name.set("john"), p.id.set(15L)).where(p.id >= 2)
-
-    println(DoobieQuery.update(update))
-
-  }
-
-  test("basic insert") {
-    val p = PersonRecord(1, "John", Timestamp.Epoch)
-
-    val insert = PersonRecord.insertAll(p)
-
-    println(insert)
-
-  }
 }

modules/store/src/test/scala/docspell/store/qb/model/CourseRecord.scala

@@ -28,7 +28,4 @@ object CourseRecord {
   def as(alias: String): Table =
     Table(Some(alias))
 
-  def update: UpdateTable =
-    UpdateTable(Table(None), None, Seq.empty)
-
 }

modules/store/src/test/scala/docspell/store/qb/model/PersonRecord.scala

@@ -2,9 +2,6 @@ package docspell.store.qb.model
 
 import docspell.store.qb._
 import docspell.common._
-import doobie.implicits._
-import docspell.store.impl.DoobieMeta._
-import doobie._
 
 case class PersonRecord(id: Long, name: String, created: Timestamp)
 
@@ -24,15 +21,4 @@ object PersonRecord {
   def as(alias: String): Table =
     Table(Some(alias))
 
-  def table: Table = Table(None)
-
-  def update(set: UpdateTable.Setter[_], sets: UpdateTable.Setter[_]*): UpdateTable =
-    UpdateTable(table, None, sets :+ set)
-
-  def insertAll(v: PersonRecord): ConnectionIO[Int] =
-    InsertTable(
-      table,
-      table.all,
-      fr"${v.id},${v.name},${v.created}"
-    ).toFragment.update.run
 }