implement relation API endpoints - closes lichess-org#4398

See https://lichess.org/api#tag/Relations

Author: ornicar

app/controllers/Relation.scala

@@ -1,11 +1,15 @@
 package controllers
 
+import play.api.libs.iteratee._
 import play.api.libs.json.Json
+import play.api.mvc._
 
 import lila.api.Context
 import lila.app._
 import lila.common.paginator.{ Paginator, AdapterLike, PaginatorJson }
+import lila.common.{ HTTPRequest, MaxPerSecond }
 import lila.relation.Related
+import lila.relation.RelationStream._
 import lila.user.{ User => UserModel, UserRepo }
 import views._
 
@@ -76,6 +80,23 @@ object Relation extends LilaController {
     }
   }
 
+  def apiFollowing(name: String) = apiRelation(name, Direction.Following)
+
+  def apiFollowers(name: String) = apiRelation(name, Direction.Followers)
+
+  private def apiRelation(name: String, direction: Direction) = Action.async { req =>
+    UserRepo.named(name) flatMap {
+      _ ?? { user =>
+        import Api.limitedDefault
+        Api.GlobalLinearLimitPerIP(HTTPRequest lastRemoteAddress req) {
+          Api.jsonStream {
+            env.stream.follow(user, direction, MaxPerSecond(20)) &> Enumeratee.map(Env.api.userApi.one)
+          } |> fuccess
+        }
+      }
+    }
+  }
+
   private def jsonRelatedPaginator(pag: Paginator[Related]) = {
     import lila.user.JsonView.nameWrites
     import lila.relation.JsonView.relatedWrites

build.sbt

@@ -329,7 +329,7 @@ lazy val plan = module("plan", Seq(common, user, notifyModule)).settings(
 )
 
 lazy val relation = module("relation", Seq(common, db, memo, hub, user, game, pref)).settings(
-  libraryDependencies ++= provided(play.api, reactivemongo.driver)
+  libraryDependencies ++= provided(play.api, reactivemongo.driver, reactivemongo.iteratees)
 )
 
 lazy val pref = module("pref", Seq(common, db, user)).settings(

conf/routes

@@ -494,6 +494,8 @@ GET   /api                             controllers.Api.index
 POST  /api/users                       controllers.Api.usersByIds
 GET   /api/user/:name                  controllers.Api.user(name: String)
 GET   /api/user/:name/activity         controllers.Api.activity(name: String)
+GET   /api/user/:name/following        controllers.Relation.apiFollowing(name: String)
+GET   /api/user/:name/followers        controllers.Relation.apiFollowers(name: String)
 GET   /api/game/:id                    controllers.Api.game(id: String)
 GET   /api/games/team/:teamId          controllers.Api.gamesVsTeam(teamId: String)
 GET   /api/tournament                  controllers.Api.currentTournaments

modules/relation/src/main/Env.scala

@@ -39,6 +39,8 @@ final class Env(
     maxBlock = MaxBlock
   )
 
+  lazy val stream = new RelationStream(coll = coll)(system)
+
   val online = new OnlineDoing(
     api,
     lightUser = lightUserApi.sync,

modules/relation/src/main/RelationStream.scala

@@ -0,0 +1,44 @@
+package lila.relation
+
+import play.api.libs.iteratee._
+import reactivemongo.api.ReadPreference
+import reactivemongo.play.iteratees.cursorProducer
+import scala.concurrent.duration._
+
+import lila.common.MaxPerSecond
+import lila.db.dsl._
+import lila.user.{ User, UserRepo }
+
+final class RelationStream(coll: Coll)(implicit system: akka.actor.ActorSystem) {
+
+  import RelationStream._
+
+  def follow(user: User, direction: Direction, perSecond: MaxPerSecond): Enumerator[User] = {
+    val field = direction match {
+      case Direction.Following => "u2"
+      case Direction.Followers => "u1"
+    }
+    val projection = $doc(field -> true, "_id" -> false)
+    val query = direction match {
+      case Direction.Following => coll.find($doc("u1" -> user.id, "r" -> Follow), projection)
+      case Direction.Followers => coll.find($doc("u2" -> user.id, "r" -> Follow), projection)
+    }
+    query.copy(options = query.options.batchSize(perSecond.value))
+      .cursor[Bdoc](readPreference = ReadPreference.secondaryPreferred)
+      .bulkEnumerator() &>
+      lila.common.Iteratee.delay(1 second) &>
+      Enumeratee.mapM { docs =>
+        UserRepo usersFromSecondary docs.toSeq.flatMap(_.getAs[User.ID](field))
+      } &>
+      Enumeratee.mapConcat(_.toSeq)
+  }
+}
+
+object RelationStream {
+
+  sealed trait Direction
+  object Direction {
+    case object Following extends Direction
+    case object Followers extends Direction
+  }
+}