Rename space -> folder

modules/backend/src/main/scala/docspell/backend/BackendApp.scala

@@ -35,7 +35,7 @@ trait BackendApp[F[_]] {
   def mail: OMail[F]
   def joex: OJoex[F]
   def userTask: OUserTask[F]
-  def space: OSpace[F]
+  def folder: OFolder[F]
 }
 
 object BackendApp {
@@ -68,7 +68,7 @@ object BackendApp {
         JavaMailEmil(blocker, Settings.defaultSettings.copy(debug = cfg.mailDebug))
       mailImpl     <- OMail(store, javaEmil)
       userTaskImpl <- OUserTask(utStore, queue, joexImpl)
-      spaceImpl    <- OSpace(store)
+      folderImpl   <- OFolder(store)
     } yield new BackendApp[F] {
       val login: Login[F]            = loginImpl
       val signup: OSignup[F]         = signupImpl
@@ -86,7 +86,7 @@ object BackendApp {
       val mail                       = mailImpl
       val joex                       = joexImpl
       val userTask                   = userTaskImpl
-      val space                      = spaceImpl
+      val folder                     = folderImpl
     }
 
   def apply[F[_]: ConcurrentEffect: ContextShift](

modules/backend/src/main/scala/docspell/backend/ops/OFolder.scala

@@ -0,0 +1,110 @@
+package docspell.backend.ops
+
+import cats.effect._
+
+import docspell.common._
+import docspell.store.{AddResult, Store}
+import docspell.store.records.{RFolder, RUser}
+import docspell.store.queries.QFolder
+
+trait OFolder[F[_]] {
+
+  def findAll(
+      account: AccountId,
+      ownerLogin: Option[Ident],
+      nameQuery: Option[String]
+  ): F[Vector[OFolder.FolderItem]]
+
+  def findById(id: Ident, account: AccountId): F[Option[OFolder.FolderDetail]]
+
+  /** Adds a new folder. If `login` is non-empty, the `folder.user`
+    * property is ignored and the user-id is determined by the given
+    * login name.
+    */
+  def add(folder: RFolder, login: Option[Ident]): F[AddResult]
+
+  def changeName(
+      folder: Ident,
+      account: AccountId,
+      name: String
+  ): F[OFolder.FolderChangeResult]
+
+  def addMember(
+      folder: Ident,
+      account: AccountId,
+      member: Ident
+  ): F[OFolder.FolderChangeResult]
+
+  def removeMember(
+      folder: Ident,
+      account: AccountId,
+      member: Ident
+  ): F[OFolder.FolderChangeResult]
+
+  def delete(id: Ident, account: AccountId): F[OFolder.FolderChangeResult]
+}
+
+object OFolder {
+
+  type FolderChangeResult = QFolder.FolderChangeResult
+  val FolderChangeResult = QFolder.FolderChangeResult
+
+  type FolderItem = QFolder.FolderItem
+  val FolderItem = QFolder.FolderItem
+
+  type FolderDetail = QFolder.FolderDetail
+  val FolderDetail = QFolder.FolderDetail
+
+  def apply[F[_]: Effect](store: Store[F]): Resource[F, OFolder[F]] =
+    Resource.pure[F, OFolder[F]](new OFolder[F] {
+      def findAll(
+          account: AccountId,
+          ownerLogin: Option[Ident],
+          nameQuery: Option[String]
+      ): F[Vector[FolderItem]] =
+        store.transact(QFolder.findAll(account, None, ownerLogin, nameQuery))
+
+      def findById(id: Ident, account: AccountId): F[Option[FolderDetail]] =
+        store.transact(QFolder.findById(id, account))
+
+      def add(folder: RFolder, login: Option[Ident]): F[AddResult] = {
+        val insert = login match {
+          case Some(n) =>
+            for {
+              user <- RUser.findByAccount(AccountId(folder.collectiveId, n))
+              s = user.map(u => folder.copy(owner = u.uid)).getOrElse(folder)
+              n <- RFolder.insert(s)
+            } yield n
+
+          case None =>
+            RFolder.insert(folder)
+        }
+        val exists = RFolder.existsByName(folder.collectiveId, folder.name)
+        store.add(insert, exists)
+      }
+
+      def changeName(
+          folder: Ident,
+          account: AccountId,
+          name: String
+      ): F[FolderChangeResult] =
+        store.transact(QFolder.changeName(folder, account, name))
+
+      def addMember(
+          folder: Ident,
+          account: AccountId,
+          member: Ident
+      ): F[FolderChangeResult] =
+        store.transact(QFolder.addMember(folder, account, member))
+
+      def removeMember(
+          folder: Ident,
+          account: AccountId,
+          member: Ident
+      ): F[FolderChangeResult] =
+        store.transact(QFolder.removeMember(folder, account, member))
+
+      def delete(id: Ident, account: AccountId): F[FolderChangeResult] =
+        store.transact(QFolder.delete(id, account))
+    })
+}

modules/backend/src/main/scala/docspell/backend/ops/OSpace.scala

@@ -1,110 +0,0 @@
-package docspell.backend.ops
-
-import cats.effect._
-
-import docspell.common._
-import docspell.store.{AddResult, Store}
-import docspell.store.records.{RSpace, RUser}
-import docspell.store.queries.QSpace
-
-trait OSpace[F[_]] {
-
-  def findAll(
-      account: AccountId,
-      ownerLogin: Option[Ident],
-      nameQuery: Option[String]
-  ): F[Vector[OSpace.SpaceItem]]
-
-  def findById(id: Ident, account: AccountId): F[Option[OSpace.SpaceDetail]]
-
-  /** Adds a new space. If `login` is non-empty, the `space.user`
-    * property is ignored and the user-id is determined by the given
-    * login name.
-    */
-  def add(space: RSpace, login: Option[Ident]): F[AddResult]
-
-  def changeName(
-      space: Ident,
-      account: AccountId,
-      name: String
-  ): F[OSpace.SpaceChangeResult]
-
-  def addMember(
-      space: Ident,
-      account: AccountId,
-      member: Ident
-  ): F[OSpace.SpaceChangeResult]
-
-  def removeMember(
-      space: Ident,
-      account: AccountId,
-      member: Ident
-  ): F[OSpace.SpaceChangeResult]
-
-  def delete(id: Ident, account: AccountId): F[OSpace.SpaceChangeResult]
-}
-
-object OSpace {
-
-  type SpaceChangeResult = QSpace.SpaceChangeResult
-  val SpaceChangeResult = QSpace.SpaceChangeResult
-
-  type SpaceItem = QSpace.SpaceItem
-  val SpaceItem = QSpace.SpaceItem
-
-  type SpaceDetail = QSpace.SpaceDetail
-  val SpaceDetail = QSpace.SpaceDetail
-
-  def apply[F[_]: Effect](store: Store[F]): Resource[F, OSpace[F]] =
-    Resource.pure[F, OSpace[F]](new OSpace[F] {
-      def findAll(
-          account: AccountId,
-          ownerLogin: Option[Ident],
-          nameQuery: Option[String]
-      ): F[Vector[SpaceItem]] =
-        store.transact(QSpace.findAll(account, None, ownerLogin, nameQuery))
-
-      def findById(id: Ident, account: AccountId): F[Option[SpaceDetail]] =
-        store.transact(QSpace.findById(id, account))
-
-      def add(space: RSpace, login: Option[Ident]): F[AddResult] = {
-        val insert = login match {
-          case Some(n) =>
-            for {
-              user <- RUser.findByAccount(AccountId(space.collectiveId, n))
-              s = user.map(u => space.copy(owner = u.uid)).getOrElse(space)
-              n <- RSpace.insert(s)
-            } yield n
-
-          case None =>
-            RSpace.insert(space)
-        }
-        val exists = RSpace.existsByName(space.collectiveId, space.name)
-        store.add(insert, exists)
-      }
-
-      def changeName(
-          space: Ident,
-          account: AccountId,
-          name: String
-      ): F[SpaceChangeResult] =
-        store.transact(QSpace.changeName(space, account, name))
-
-      def addMember(
-          space: Ident,
-          account: AccountId,
-          member: Ident
-      ): F[SpaceChangeResult] =
-        store.transact(QSpace.addMember(space, account, member))
-
-      def removeMember(
-          space: Ident,
-          account: AccountId,
-          member: Ident
-      ): F[SpaceChangeResult] =
-        store.transact(QSpace.removeMember(space, account, member))
-
-      def delete(id: Ident, account: AccountId): F[SpaceChangeResult] =
-        store.transact(QSpace.delete(id, account))
-    })
-}