View source for Scala Revisit 2025

=Introduction=
This page is to summarize stuff I needed when revisiting Scala. The last time I looked at this was 2021 and I guess things have changed a bit, both for me and for Scala
=Building Scala Projects=
There appears to be two key ways to do this, with '''Mill''' or SBT. 
==Create Project==
To do this you do
 sbt new playframework/play-scala-seed.g8

==build.sbt==
A bit about packages so I remember. They are made up of '''Group ID''', '''Artifact ID''' and '''Version''' e.g. 
 "org.playframework" %% "play-slick" % "6.2.0". 
You can go to https://index.scala-lang.org/ to find packages. An example of a build.sbt is
<syntaxhighlight lang="scala">
name := """play-scala-seed"""
organization := "nz.co.bibble"

version := "1.0-SNAPSHOT"

lazy val root = (project in file(".")).enablePlugins(PlayScala)

scalaVersion := "2.13.16"

// Add individual dependencies
libraryDependencies += guice
libraryDependencies += "org.scalatestplus.play" %% "scalatestplus-play" % "7.0.2" % Test

// Add Database and Slick dependencies
libraryDependencies ++= Seq(
  "org.playframework" %% "play-slick" % "6.2.0",
  "org.playframework" %% "play-slick-evolutions" % "6.2.0",
  "org.postgresql" % "postgresql" % "42.7.3",
  "com.typesafe.slick" %% "slick" % "3.6.1",
  "com.typesafe.slick" %% "slick-hikaricp" % "3.6.1"
)
</syntaxhighlight>

==Commands I have used==
Seems to be a bit Mavenesk to the commands I have used so far are
 sbt update // Update Packages, looks like vscode handles this too.
 sbt reload
 sbt run
 sbt compile
 sbt clean
 sbt scalafixAll

==scalefixAll==
This is the sbt plugin for Scalafix, a refactoring and linting tool for Scala. For instructions on how to install the plugin, refer to the website. Which can be found at https://github.com/scalacenter/sbt-scalafix. When I installed it I need to add the following to plugins.sbt.
<syntaxhighlight lang="scala">
addSbtPlugin("ch.epfl.scala" % "sbt-scalafix" % "0.14.3")
</syntaxhighlight>
I also needed to create a .scalafix.conf
<syntaxhighlight lang="scala">
rules = [
  RemoveUnused,
  DisableSyntax
]

DisableSyntax.noVars = true
DisableSyntax.noNulls = true
DisableSyntax.noThrows = true
</syntaxhighlight>
This did reorganize my imports and removed unused. Definitely should be used at check-in and in CI/CD

=Finding Packages=
Have yet discovered the way to find package dependencies. The individual documentation information e.g. https://www.playframework.com/documentation/3.0.x/PlaySlick but I am looking more for namespace. Hang on lets ask the robot. It seems https://index.scala-lang.org is the way to go
=VS Code=
Took a while to get this going. It is always the ecosystem which takes the time. So I guess you install the Scala megapack or what ever it is called. Create a launch.json. The trick are to set the buildTarget correctly. It offered me under "Metals:Display Build Target Info", "dvdrental_api_scala-build", "root" and "root-test". I of course choose the name of the project - derrrrr. 
<syntaxhighlight lang="json">
{
  "configurations": [
    {
      "type": "scala",
      "request": "attach",
      "name": "dvdrental",
      "buildTarget": "root",
      "hostName": "localhost",
      "port": 5005
    }
  ]
}
</syntaxhighlight>
Now, set your breakpoints and run in debug with
<syntaxhighlight lang="bash">
sbt -jvm-debug 5005 run
</syntaxhighlight>

=REST API=
When I build a REST API I usually use the controller->Service->DAO approach. I will try and touch on the things as they happen so I capture the struggles.
==Configuration==
I need to pass configuration to my project as always. With slick you can do this by putting this into the application.conf. This is a format called '''HOCON''' which stands for Human Optimized Config Object Notation. It can replace values with environment variables.
<syntaxhighlight lang="scala">
slick.dbs.default.profile = "slick.jdbc.PostgresProfile$"
slick.dbs.default.db {
    driver = "org.postgresql.Driver",
    url = ${?DATABASE_URL}
    user = ${?DATABASE_USER}
    password = ${?DATABASE_PASSWORD}
}
</syntaxhighlight>

==Dependency Injection==
Never used this and is here to show an example. Need to check doing things the right way. So basically you write the classes as you would normally do. Here is the DAO and DAO. Note interfaces are '''traits''' in Scala. I am a bit rusty in Scala hahaha
<syntaxhighlight lang="scala">
trait ActorDAO {
  def all(): Future[Seq[Actor]]
...
}
</syntaxhighlight>
And the implementation.
<syntaxhighlight lang="scala">
@Singleton
class ActorDAOImpl @Inject() (
    protected val dbConfigProvider: DatabaseConfigProvider
)(implicit ec: ExecutionContext)
    extends HasDatabaseConfigProvider[JdbcProfile]
    with ActorDAO {

  import profile.api._

  private val actors = TableQuery[ActorTable]

  // Fetch all actors
  def all(): Future[Seq[Actor]] =
    db.run(actors.result)
...
}
</syntaxhighlight>
Then we need to make a class to hold the mapping of trait to implementation so made a file app/modules/DaoModule.scala
<syntaxhighlight lang="scala">
class DaoModule extends AbstractModule {
  override def configure(): Unit = {
    bind(classOf[ActorDAO]).to(classOf[ActorDAOImpl])
  }
}
</syntaxhighlight>
And then we need to have this loaded at startup via the application.conf
<syntaxhighlight lang="scala">
play.modules.enabled += "modules.DaoModule"
</syntaxhighlight>
==Routing==
This is relatively easy as it is done via configuration in a file under conf/routes
<syntaxhighlight lang="scala">
GET /actor controllers.ActorController.getAll()
GET /film  controllers.FilmController.getAll()
</syntaxhighlight> 
==DAO==
Well made an implementation of the ActorDAO but also needed to make a ActorTable class which is really just a mapper from the database to the case class. I will need to understand again the def * bit. I understand it is a two-way mapping from a Tuple (not two things in scala) to a case class. The object is a companion object or static function on ActorTable, a bit kotlinesk - haha
<syntaxhighlight lang="scala">
class ActorTable(tag: Tag) extends Table[Actor](tag, "actor") {
  def actorId = column[Long]("actor_id", O.PrimaryKey, O.AutoInc)
  def firstName = column[String]("first_name")
  def lastName = column[String]("last_name")
  def lastUpdate = column[Timestamp]("last_update")
  def * = (
    actorId,
    firstName,
    lastName,
    lastUpdate
  ) <> (Actor.tupled, Actor.unapply)
}

object ActorTable {
  val actors = TableQuery[ActorTable]
}
</syntaxhighlight>
Funny my this is removed in Scala 3 - well sort of. They replaced it with mapTo but in only supports 12 fields. So for actor all good but for Film not so good.
<syntaxhighlight lang="scala">
class ActorTable(tag: Tag) extends Table[Actor](tag, "actor") {
  def actorId = column[Long]("actor_id", O.PrimaryKey, O.AutoInc)
  def firstName = column[String]("first_name")
  def lastName = column[String]("last_name")
  def lastUpdate = column[Timestamp]("last_update")
  def * : ProvenShape[Actor] = (
    actorId,
    firstName,
    lastName,
    lastUpdate
  ).mapTo[Actor]
}

object ActorTable {
  val actors = TableQuery[ActorTable]
}
</syntaxhighlight>
For film I had to go back to the Tuple approach but to do this I needed to add the tupled to the model Film case class
<syntaxhighlight lang="scala">
package models

case class Film(
    filmId: Long,
    title: String,
    description: String,
    releaseYear: String,
    languageId: Long,
    rentalDuration: Long,
    rentalRate: Double,
    length: Long,
    replacementCost: Double,
    rating: String,
    lastUpdate: String,
    specialFeatures: List[String],
    fullText: String
)

object Film {
  val tupled = Film.apply.tupled
}
</syntaxhighlight>
And revert back to the old way of doing it. The tupled in Scala 3 is no longer free and you have to define it.
<syntaxhighlight lang="scala">
class FilmTable(tag: Tag) extends Table[Film](tag, "film") {
  def filmId = column[Long]("film_id", O.PrimaryKey, O.AutoInc)
...
  def fullText = column[String]("fulltext")

  def * : ProvenShape[Film] = (
    filmId,
...
    fullText
  ) <> (Film.tupled, Film.unapply)
}

object FilmTable {
  val films = TableQuery[FilmTable]
}
</syntaxhighlight>
I struggled a lot with the syntax for the 
{| class="wikitable"
! Syntax Component !! Meaning !! Plain English
|-
| `def *` || Defines a method named `*` || Slick convention for mapping a DB row to a Scala object
|-
| `: ProvenShape[Film]` || Return type of the method || “This mapping produces a `Film` object”
|-
| `(filmId, title, ..., fullText)` || Tuple of table columns || These are the columns Slick reads from the DB
|-
| `<>` || Slick’s two-way mapping operator || Bridges between tuple and case class
|-
| `Film.tupled` || Converts a tuple into a `Film` || Used when reading from the DB
|-
| `Film.unapply` || Converts a `Film` into a tuple || Used when writing to the DB
|}
When you did deeper it start to make sense. The <> is just a method e.g.
 def <>[P, R](f: P => R, g: R => Option[P]): MappedProjection[R, P]
==Custom Database Types==
It the postgres database we have custom types. One is Rating which can be one of G,PG,PG13,R, NC17. To mimic this in rust I used an enum. This can be done for scala too. First we create a type. It got a bit message as I want to cater for bad data.
<syntaxhighlight lang="scala">
package models

// Scala 3 enum with explicit DB string value (keeps DB labels flexible)
enum Rating(val dbValue: String) {
  case G extends Rating("G")
  case PG extends Rating("PG")
  case PG13 extends Rating("PG-13")
  case R extends Rating("R")
  case NC17 extends Rating("NC-17")
  // Unknown preserves the original DB value when the database contains
  // a label not currently modeled by the enum. This avoids throwing on
  // unexpected database values and keeps the raw text available.
  case Unknown(override val dbValue: String) extends Rating(dbValue)
}
...
</syntaxhighlight>
Now we can handle the Unknown values. 
<syntaxhighlight lang="scala">
object Rating {
  // Explicit list of known singleton cases. We avoid using `values` because
  // the enum also defines a non-singleton `Unknown` case and Scala won't
  // generate a `values` array for enums with non-singleton cases.
  val known: Seq[Rating] = Seq(G, PG, PG13, R, NC17)

  def fromDb(s: String): Option[Rating] = known.find(_.dbValue == s)

  /** Convert from a DB string to a Rating, but never throw: unknown labels are
    * wrapped in `Rating.Unknown(value)`.
    */
  def fromDbOrUnknown(s: String): Rating = fromDb(s).getOrElse(Unknown(s))

  // throws if not found (use with caution)
  def unsafeFromDb(s: String): Rating =
    fromDb(s).getOrElse(
      throw new IllegalArgumentException(s"Unknown Rating value: $s")
    )
...
</syntaxhighlight>
And now the JSON stuff to 
<syntaxhighlight lang="scala">
  // Play JSON implicits so Json macros can find them
  import play.api.libs.json._

  implicit val ratingWrites: Writes[Rating] = Writes(r => JsString(r.dbValue))
  implicit val ratingReads: Reads[Rating] = Reads {
    case JsString(s) =>
      fromDb(s) match {
        case Some(r) => JsSuccess(r)
        case None    => JsError(s"Unknown rating: $s")
      }
    case _ => JsError("Rating must be a string")
  }

  // See below for the formatting.
  implicit val ratingFormat: Format[Rating] = Format(ratingReads, ratingWrites)
}
</syntaxhighlight>
Now in utils/JsonFormats we write the Formater. This is quite a bit of code for one Enum and we are done yet
<syntaxhighlight lang="scala">
package utils

object JsonFormats {
  implicit val ratingFormat: Format[Rating] = new Format[Rating] {
    def writes(r: Rating): JsValue = JsString(r.dbValue)
    def reads(json: JsValue): JsResult[Rating] =
      json.validate[String].flatMap { s =>
        Rating.fromDb(s) match {
          case Some(r) => JsSuccess(r)
          case None    => JsError(s"Unknown rating: $s")
        }
      }
  }
}
</syntaxhighlight>
In the postgres we need to handle this new type. We do this by defining ColumnType and providing functions for from and to the database
<syntaxhighlight lang="scala">
package db

import com.github.tminglei.slickpg._
import play.api.libs.json.JsValue
import play.api.libs.json._
import models.Rating
import models.Year

import slick.jdbc.JdbcType
import slick.ast.BaseTypedType

trait MyPostgresProfile
    extends ExPostgresProfile
    with PgArraySupport
    with PgDate2Support
    ....  {
  def pgjson =
    "jsonb" // jsonb support is in postgres 9.4.0 onward; for 9.3.x use "json"

  // Add back `capabilities.insertOrUpdate` to enable native `upsert` support; for postgres 9.5+
  override protected def computeCapabilities: Set[slick.basic.Capability] =
    super.computeCapabilities + slick.jdbc.JdbcCapabilities.insertOrUpdate

  override val api = MyAPI

  object MyAPI
      extends ExtPostgresAPI
      with ArrayImplicits
      with Date2DateTimeImplicitsDuration
      ... {

    // Add custom column Rating mapping
    implicit val ratingColumnType: JdbcType[Rating] & BaseTypedType[Rating] =
      MappedColumnType.base[Rating, String](
        // to DB
        (r: Rating) => r.dbValue,
        // from DB (never throws; returns Unknown(value) if not found)
        (s: String) => Rating.fromDbOrUnknown(s)
      )
...
</syntaxhighlight>
Now at last we can use it in out FilmTable class
<syntaxhighlight lang="scala" highlight="7">
package dao

import models.Film

import db.MyPostgresProfile.api._
import db.MyPostgresProfile.MyAPI.strListTypeMapper
import db.MyPostgresProfile.MyAPI.ratingColumnType
import db.MyPostgresProfile.MyAPI.yearColumnType
import slick.lifted.ProvenShape
import models.{Rating, Year}

class FilmTable(tag: Tag) extends Table[Film](tag, "film") {
  def filmId = column[Long]("film_id", O.PrimaryKey, O.AutoInc)
  def title = column[String]("title")
...
  def rating = column[Rating]("rating", O.SqlType("rating"))
...
  def fullText = column[String]("fulltext", O.SqlType("tsvector"))
  def * : ProvenShape[Film] = (
    filmId,
    title,
...
    rating,
    fullText
  ) <> (Film.tupled, Film.unapply)
}
....
</syntaxhighlight>
=Dependency Inject=
Gosh this looks an awful lot like Dagger for Android. This is a package called guice. https://github.com/google/guice. It basically seems to work the same as Dagger. Basically you do the following for this simple example.
*Create you thing e.g. a Service
*Create a module
*Add the module to the application.conf
==Create Service==
I wanted to emulate the Update JWKS that I wrote in Rust. I had already done it in Java but it does seem rather easy to do in Scala. (Wish it had two l's Scalla as I would pronounce it correctly). The service uses something called the ActorSystem provided with Play 3 which is now Apache Pekko formally Akka after a bun fight around BSL. Does get more simpler than this.
<syntaxhighlight lang="scala">
@Singleton
class JwksRefreshService @Inject() (
    actorSystem: ActorSystem,
    verifier: JwtVerifier,
    configuration: Configuration,
    lifecycle: ApplicationLifecycle
)(implicit ec: ExecutionContext)
    extends Logging {

  // Add logging a instantiation
  logger.info("Starting JwksRefreshService to periodically refresh JWKS keys")

  private val refreshIntervalSeconds = configuration
    .getOptional[Int]("keycloak.jwks-refresh-seconds")
    .getOrElse(600)

  // schedule via ActorSystem scheduler
  private val cancellable: Cancellable =
    actorSystem.scheduler.scheduleAtFixedRate(
      0.seconds,
      refreshIntervalSeconds.seconds
    )(() => {
      logger.info(s"Refreshing JWKS keys every $refreshIntervalSeconds seconds")

      // trigger refresh asynchronously
      verifier.refreshKeys()
      ()
    })

  // cancel the scheduled job on application shutdown
  lifecycle.addStopHook { () =>
    try {
      logger.info(
        "Shutting down JwksRefreshService and cancelling scheduled refresh"
      )
      cancellable.cancel()
    } catch {
      case t: Throwable =>
        logger.warn("Error cancelling JWKS refresh cancellable", t)
    }
    scala.concurrent.Future.successful(())
  }
}
</syntaxhighlight>
==Create a module==
Now like dagger we wrap it in a module. And just like Dagger we include the necessary components.
<syntaxhighlight lang="scala">
class AuthenticationModule extends AbstractModule {
  override def configure(): Unit = {
    bind(classOf[authentication.services.JwksRefreshService]).asEagerSingleton()
  }

  @Provides
  @Singleton
  def provideJwtVerifier(
      ws: WSClient,
      configuration: Configuration
  )(using ec: ExecutionContext): JwtVerifier = {
    val issuer = configuration
      .getOptional[String]("keycloak.issuer")
      .getOrElse(
        throw new IllegalStateException("keycloak.issuer not configured")
      )

    val audience = configuration
      .getOptional[String]("keycloak.audience")
      .getOrElse(
        throw new IllegalStateException("keycloak.audience not configured")
      )

    val verifier = new JwtVerifier(ws, issuer, audience, Clock.systemUTC())

    verifier
  }
}
</syntaxhighlight>
==Add the module to the application.conf==
And just for completeness I show it in the application.conf
<syntaxhighlight lang="scala">
play.modules.enabled += "modules.AuthenticationModule"
</syntaxhighlight>