Added silhouette for authentication with a basic authentication flow

Author: espinhogr

README.md

@@ -1,6 +1,15 @@
 # README #
 
-Seed project for Play framework + ScalaJS using Apollo client and Sangria.
+Seed project for Play framework + ScalaJS using React, Apollo client and Sangria.
+Under the hood it uses:
+- GraphQL
+- Apollo Client
+- Play framework
+- Sangria
+- Silhouette (Authentication)
+- Slinky (React for Scala.js)
+- Antd (Components for React)
+- Slick with codegen and play-evolutions
 
 
 ## Development Guide
@@ -26,6 +35,12 @@ docker run --name=test_db_server -e 'MYSQL_ROOT_PASSWORD=root' -e 'MYSQL_ROOT_HO
 - web_client/Compile/managedSources: generates schema.graphql and query/mutation objects for the client
 - assembly: generates the uber jar 
 
+## Usage
+
+The default login for the user interface is:
+- username: admin
+- password: admin
+
 ## Problems
 
 - WebpackDevServer is not used at the moment

project/DatabaseUtils.scala

@@ -13,7 +13,7 @@ object DatabaseUtils {
   val slickOutputDir = settingKey[File]("The directory where the database mappings are outputted")
   val runEvolutions = taskKey[Seq[File]]("Runs the evolutions on the database")
 
-  def generateSlickTables(baseDir: File, outputDir: File, classPath: Classpath, runner: ScalaRun, stream: TaskStreams): Seq[File] = {
+  def generateSlickTables(baseDir: File, outputDir: File, classPath: Seq[File], runner: ScalaRun, stream: TaskStreams): Seq[File] = {
     val config = ConfigFactory.parseFile(new File(s"${baseDir.getAbsolutePath}/conf/application.conf")).resolve()
     val url = config.getString("slick.dbs.default.db.url")
     val jdbcDriver = config.getString("slick.dbs.default.db.driver")
@@ -22,10 +22,10 @@ object DatabaseUtils {
     val user = config.getString("slick.dbs.default.db.user")
     val password = config.getString("slick.dbs.default.db.password")
     val ignoreInvalidDefaults = "true"
-    val generatorClass = "slick.codegen.SourceCodeGenerator"
+    val generatorClass = "infrastructure.JodaAwareSourceCodeGenerator"
     val outputMultipleFiles = "true"
     val generatorOptions = Array(slickProfile, jdbcDriver, url, outputDir.getPath, pkg, user, password, ignoreInvalidDefaults, generatorClass, outputMultipleFiles)
-    runner.run("slick.codegen.SourceCodeGenerator", classPath.files, generatorOptions, stream.log).failed foreach (sys error _.getMessage)
+    runner.run("slick.codegen.SourceCodeGenerator", classPath, generatorOptions, stream.log).failed foreach (sys error _.getMessage)
     stream.log.info("Written slick mappings in directory " + outputDir)
     (outputDir / pkg.replace('.', '/')).listFiles()
   }
@@ -58,7 +58,10 @@ object DatabaseUtils {
       val srcDir = (Compile / sourceDirectory).value
       val compilers = Keys.compilers.value
       val classPath = (Compile / dependencyClasspath).value
-      val fileToCompile = srcDir / "infrastructure/ApplyEvolutions.scala"
+      val filesToCompile = Seq(
+        srcDir / "infrastructure/ApplyEvolutions.scala",
+        srcDir / "infrastructure/JodaAwareSourceCodeGenerator.scala"
+      )
       val outputDir = (Compile / classDirectory).value
       val resourcesDir = (Compile / resourceDirectory).value
       val options = Shared.compileOptions
@@ -69,7 +72,7 @@ object DatabaseUtils {
 
       QuickCompiler.scalac(
         compilers,
-        Seq(fileToCompile),
+        filesToCompile,
         QuickCompiler.noChanges,
         classPath.map(_.data),
         outputDir,
@@ -99,7 +102,7 @@ object DatabaseUtils {
       runEvolutions.value
       val dir = slickOutputDir.value
       val baseDir = baseDirectory.value
-      val classPath = (Compile / dependencyClasspath).value
+      val classPath = (Compile / dependencyClasspath).value.files :+ (Compile / classDirectory).value
       val runner = (Compile / Keys.runner).value
       val stream = streams.value
       generateSlickTables(baseDir, dir, classPath, runner, stream)

project/ProjectVersionManager.scala

@@ -4,7 +4,7 @@ import sbt.Keys._
 object ProjectVersionManager {
   def writeConfig(projectId: String, projectName: String, projectPort: Int) = Def.task {
     val content =s"""
-                    |package util
+                    |package version.util
                     |
                     |object Version {
                     |  val projectId = "$projectId"

project/Server.scala

@@ -20,6 +20,7 @@ object Server {
 
   val playSlickV = "4.0.0"
   val slickV = "3.3.0"
+  val silhouetteV = "6.0.0-SNAPSHOT"
 
   private[this] val dependencies = {
     Seq(
@@ -31,7 +32,12 @@ object Server {
       "com.typesafe.play" %% "play-slick-evolutions" % playSlickV,
       "com.typesafe.slick" %% "slick" % slickV,
       "com.typesafe.slick" %% "slick-codegen" % slickV,
-      "mysql" % "mysql-connector-java" % "6.0.6"
+      "mysql" % "mysql-connector-java" % "6.0.6",
+      "com.mohiva" %% "play-silhouette" % silhouetteV,
+      "com.mohiva" %% "play-silhouette-password-bcrypt" % silhouetteV,
+      "com.mohiva" %% "play-silhouette-crypto-jca" % silhouetteV,
+      "com.mohiva" %% "play-silhouette-persistence" % silhouetteV,
+      "com.github.tototoshi" %% "slick-joda-mapper" % "2.4.0"
     )
   }
 

project/Shared.scala

@@ -18,9 +18,10 @@ object Shared {
   private[this] val profilingEnabled = false
 
   val compileOptions = Seq(
-    "-target:jvm-1.8", "-encoding", "UTF-8", "-feature", "-deprecation", "-explaintypes", "-feature", "-unchecked",
+    "-target:jvm-1.8", "-encoding", "UTF-8", "-feature", "-deprecation", "-explaintypes", "-unchecked",
     "–Xcheck-null", "-Xfatal-warnings", /* "-Xlint", */ "-Xcheckinit", "-Xfuture", "-Yrangepos", "-Ypartial-unification",
-    "-Yno-adapted-args", "-Ywarn-inaccessible", "-Ywarn-nullary-override", "-Ywarn-numeric-widen", "-Ywarn-infer-any"
+    "-Yno-adapted-args", "-Ywarn-inaccessible", "-Ywarn-nullary-override", "-Ywarn-numeric-widen", "-Ywarn-infer-any",
+    "-language:postfixOps"
   ) ++ (if (profilingEnabled) {
     "-Ystatistics:typer" +: Seq("no-profiledb", "show-profiles", "generate-macro-flamegraph").map(s => s"-P:scalac-profiling:$s")
   } else { Nil })
@@ -51,7 +52,7 @@ object Shared {
       case PathList("META-INF", "io.netty.versions.properties") => MergeStrategy.first
       case PathList("sqlj", _ @ _*) => MergeStrategy.first
       case PathList("play", "reference-overrides.conf") => MergeStrategy.first
-      case PathList("util", "Version$.class") => MergeStrategy.first
+      case PathList("version","util", "Version$.class") => MergeStrategy.first
       case "module-info.class" => MergeStrategy.discard
       case "messages" => MergeStrategy.concat
       case "pom.xml" => MergeStrategy.discard

project/WebClient.scala

@@ -9,7 +9,7 @@ import webscalajs.ScalaJSWeb
 
 object WebClient {
 
-  val slinkyVer = "0.5.2+6-10d43572"
+  val slinkyVer = "0.6.0"
   val reactVer = "16.5.2"
 
   /* 
@@ -20,33 +20,37 @@ object WebClient {
    * 1. clone the repo https://github.com/apollographql/apollo-scalajs
    * 2. change the file "build.sbt" adding at its top the lines (backtick not included):
    *     ```
-   *     version in ThisBuild := "0.6.1-SNAPSHOT"
+   *     version in ThisBuild := "0.7.1-SNAPSHOT"
    *
-   *     dynver in ThisBuild := "0.6.1-SNAPSHOT"
+   *     dynver in ThisBuild := "0.7.1-SNAPSHOT"
    * 
    *     ```
    * 3. run the command (backtick not included):
    *     ```
    *     sbt publishLocal
    *     ```
    */
-  val apolloScalaJsVer = "0.6.1-SNAPSHOT"
+  val apolloScalaJsVer = "0.7.1-SNAPSHOT"
 
 
   private[this] val clientSettings = 
     Shared.commonSettings ++ WebpackUtils.wiringTasks ++ GraphqlUtils.generateTasks ++ Seq(
     scalaJSUseMainModuleInitializer := true, // Starts scalajs from a main function
     mainClass in Compile := Some("com.mypackage.Bootstrap"),
 
-    resolvers += "Apollo Bintray" at "https://dl.bintray.com/apollographql/maven/",
+    resolvers ++= Seq(
+      "Apollo Bintray" at "https://dl.bintray.com/apollographql/maven/",
+      Resolver.bintrayRepo("hmil", "maven")
+    ),
 
     libraryDependencies ++= Seq(
       "me.shadaj" %%% "slinky-web" % slinkyVer, // React DOM, HTML and SVG tags
       "me.shadaj" %%% "slinky-hot" % slinkyVer, // Hot loading, requires react-proxy package
       "me.shadaj" %%% "slinky-scalajsreact-interop" % slinkyVer, // Interop with japgolly/scalajs-react
       "com.apollographql" %%% "apollo-scalajs-core" % apolloScalaJsVer,
       "com.apollographql" %%% "apollo-scalajs-react" % apolloScalaJsVer,
-      "org.sangria-graphql" %% "sangria-circe" % "1.1.0"
+      "org.sangria-graphql" %% "sangria-circe" % "1.1.0",
+      "fr.hmil" %%% "roshttp" % "2.2.4"
     ),
     Compile / npmDependencies ++= Seq(
       "react" -> reactVer,

server/app/auth/AuthEnvironment.scala

@@ -0,0 +1,9 @@
+package auth
+
+import com.mohiva.play.silhouette.api.Env
+import com.mohiva.play.silhouette.impl.authenticators.BearerTokenAuthenticator
+
+trait AuthEnvironment extends Env {
+  type A = BearerTokenAuthenticator
+  type I = User
+}

server/app/auth/ManualUserGenerator.scala

@@ -0,0 +1,28 @@
+package auth
+
+import com.mohiva.play.silhouette.api.LoginInfo
+import com.mohiva.play.silhouette.impl.providers.CredentialsProvider
+import di.DiModule._
+import slick.jdbc.JdbcBackend.Database
+
+import scala.concurrent.Await
+import scala.concurrent.duration._
+
+/**
+  * This class is used in case you want to register a user manually.
+  * It inserts a record in the database with the user credentials.
+  */
+object ManualUserGenerator extends App {
+
+  val username = "admin"
+  val password = "admin"
+
+  val database = Database.forConfig(databaseConfigPath)
+  val passwordInfoRepository = new PasswordInfoRepository(database)
+
+  val passwordInfo = hasher.hash(password)
+  val loginInfo = LoginInfo(CredentialsProvider.ID, username)
+  println(
+    Await.result(passwordInfoRepository.add(loginInfo, passwordInfo), 5 seconds)
+  )
+}

server/app/auth/PasswordInfoRepository.scala

@@ -0,0 +1,53 @@
+package auth
+
+import com.google.inject.Inject
+import com.mohiva.play.silhouette.api.LoginInfo
+import com.mohiva.play.silhouette.api.util.PasswordInfo
+import com.mohiva.play.silhouette.persistence.daos.DelegableAuthInfoDAO
+import database.Tables
+import slick.jdbc.MySQLProfile.api._
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
+
+class PasswordInfoRepository @Inject()(db: Database) extends DelegableAuthInfoDAO[PasswordInfo] {
+
+  override def find(loginInfo: LoginInfo): Future[Option[PasswordInfo]] = {
+    val query = loginInfoById(loginInfo).result
+    db.run(query).map(_.headOption.map(pi => PasswordInfo(pi.hasher, pi.password, pi.salt)))
+  }
+
+
+  override def add(loginInfo: LoginInfo, authInfo: PasswordInfo): Future[PasswordInfo] =
+    runAndReturn(addQuery(loginInfo, authInfo), authInfo)
+
+  private def addQuery = (loginInfo: LoginInfo, authInfo: PasswordInfo) =>
+  Tables.Logininfo.map(li =>
+    (li.id, li.hasher, li.password, li.salt)
+  ) += ((idFromLoginInfo(loginInfo), authInfo.hasher, authInfo.password, authInfo.salt))
+
+
+  override def update(loginInfo: LoginInfo, authInfo: PasswordInfo): Future[PasswordInfo] =
+    runAndReturn(updateQuery(loginInfo, authInfo), authInfo)
+
+  private def updateQuery = (loginInfo: LoginInfo, authInfo: PasswordInfo) =>
+    loginInfoById(loginInfo)
+      .map(li => (li.hasher, li.password, li.salt))
+      .update((authInfo.hasher, authInfo.password, authInfo.salt))
+
+  override def save(loginInfo: LoginInfo, authInfo: PasswordInfo): Future[PasswordInfo] = {
+    val query = for {
+      isLoginInfoPresent <- loginInfoById(loginInfo).exists.result
+      queryToUse = if (isLoginInfoPresent) updateQuery else addQuery
+      action <- queryToUse(loginInfo, authInfo)
+    } yield action
+
+    runAndReturn(query, authInfo)
+  }
+
+  override def remove(loginInfo: LoginInfo): Future[Unit] = runAndReturn(loginInfoById(loginInfo).delete, ())
+
+  private def idFromLoginInfo(loginInfo: LoginInfo) = loginInfo.providerID + ":" + loginInfo.providerKey
+  private def loginInfoById(loginInfo: LoginInfo) = Tables.Logininfo.filter(_.id === idFromLoginInfo(loginInfo))
+  private def runAndReturn[T](action: DBIOAction[Int, NoStream, Nothing], ret: T) = db.run(action).map(_ => ret)
+}

server/app/auth/User.scala

@@ -0,0 +1,5 @@
+package auth
+
+import com.mohiva.play.silhouette.api.Identity
+
+case class User() extends Identity