Event sourcing example - part 1

events-1.scala

sealed trait PostEvent {
  def postId: PostId
}
case class PostAdded(postId: PostId, content: PostContent) extends PostEvent
case class PostEdited(postId: PostId, content: PostContent) extends PostEvent
case class PostDeleted(postId: PostId) extends PostEvent

events-2.scala

case class PostContent(author: String, title: String, content: String)

case class PostId(uuid: UUID)
object PostId {
  def generate(): PostId = PostId(UUID.randomUUID())

  def fromString(s: String): Option[PostId] = s match {
    case PostIdRegex(uuid) => catching(classOf[RuntimeException]) opt { PostId(UUID.fromString(uuid)) }
    case _                 => None
  }

  private val PostIdRegex = """PostId\(([a-fA-F0-9-]{36})\)""".r
}

Post.scala

/**
 * A specific blog post with its current content.
 */
case class Post(id: PostId, content: PostContent)

/**
 * The current state of blog posts, derived from all committed PostEvents.
 */
case class Posts(byId: Map[PostId, Post] = Map.empty, orderedByTimeAdded: Seq[PostId] = Vector.empty) {
  def get(id: PostId): Option[Post] = byId.get(id)
  def mostRecent(n: Int): Seq[Post] = orderedByTimeAdded.takeRight(n).reverse.map(byId)

  def apply(event: PostEvent): Posts = event match {
    case PostAdded(id, content) =>
      this.copy(byId = byId.updated(id, Post(id, content)), orderedByTimeAdded = orderedByTimeAdded :+ id)
    case PostEdited(id, content) =>
      this.copy(byId = byId.updated(id, byId(id).copy(content = content)))
    case PostDeleted(id) =>
      this.copy(byId = byId - id, orderedByTimeAdded = orderedByTimeAdded.filterNot(_ == id))
  }
}
object Posts {
  def fromHistory(events: PostEvent*): Posts = events.foldLeft(Posts())(_ apply _)
}

PostsController-1.scala

object PostsController extends Controller {
  /**
   * A Scala STM reference holding the current state of the application,
   * which is derived from all committed events.
   */
  val posts = Ref(Posts()).single

PostsController-2.scala

  /**
   * Commits an event and applies it to the current state.
   */
  def commit(event: PostEvent): Unit = {
    posts.transform(_.apply(event))
    Logger.debug("Committed event: " + event)
  }

PostsController-3.scala

  /**
   * Show an overview of the most recent blog posts.
   */
  def index = Action { implicit request =>
    Ok(views.html.posts.index(posts().mostRecent(20)))
  }

PostsController-4.scala

  /*
   * Blog content form definition.
   */
  private val postContentForm = Form(mapping(
    "author"  -> trimmedText.verifying(minLength(3)),
    "title"   -> trimmedText.verifying(minLength(3)),
    "content" -> trimmedText.verifying(minLength(3)))(PostContent.apply)(PostContent.unapply))

PostsController-5.scala

  def show(id: PostId) = Action { implicit request =>
    posts().get(id) match {
      case Some(post) => Ok(views.html.posts.edit(id, postContentForm.fill(post.content)))
      case None       => NotFound(notFound(request, None))
    }
  }

PostsController-6.scala

  def submit(id: PostId) = Action { implicit request =>
    postContentForm.bindFromRequest.fold(
      formWithErrors => BadRequest(views.html.posts.edit(id, formWithErrors)),
      postContent => {
        commit(PostEdited(id, postContent))
        Redirect(routes.PostsController.show(id)).flashing("info" -> "Post saved.")
      })
  }