More use friendly syntaxe

src/main/scala/fr/loicknuchel/safeql/gen/Generator.scala

@@ -93,4 +93,19 @@ object Generator {
     database <- reader.read()
     _ <- writer.write(database).toIO
   } yield ()
+
+  /**
+   * Allow to start with writer
+   */
+
+  def writer(writer: Writer) = new Builder(writer)
+
+  class Builder(writer: Writer) {
+    def flyway(flywayLocations: String*): FlywayGenerator = Generator.flyway(flywayLocations: _*).writer(writer)
+
+    def fromFiles(paths: List[String]): SQLFilesGenerator = Generator.fromFiles(paths).writer(writer)
+
+    def reader(reader: Reader): ReaderGenerator = Generator.reader(reader).writer(writer)
+  }
+
 }

src/main/scala/fr/loicknuchel/safeql/gen/reader/H2Reader.scala

@@ -12,21 +12,29 @@ import scala.concurrent.ExecutionContext
 class H2Reader(val url: String,
                val user: String,
                val pass: String,
-               schema: Option[String],
-               excludes: Option[String]) extends Reader {
+               val schema: Option[String],
+               val excludes: Option[String]) extends Reader {
   val driver: String = "org.h2.Driver"
   protected[gen] lazy val xa: doobie.Transactor[IO] = {
     implicit val cs: ContextShift[IO] = IO.contextShift(ExecutionContext.global)
     Transactor.fromDriverManager[IO](driver, url, user, pass)
   }
 
+  def url(u: String): H2Reader = new H2Reader(u, user, pass, schema, excludes)
+
+  def user(u: String): H2Reader = new H2Reader(url, u, pass, schema, excludes)
+
+  def pass(p: String): H2Reader = new H2Reader(url, user, p, schema, excludes)
+
+  def schema(s: String): H2Reader = new H2Reader(url, user, pass, schema = Some(s), excludes)
+
+  def excludes(regex: String): H2Reader = new H2Reader(url, user, pass, schema, excludes = Some(regex))
+
   override def read(): IO[Database] = for {
     columns <- readColumns(xa)
     crossReferences <- readCrossReferences(xa)
   } yield buildDatabase(columns, crossReferences)
 
-  def excludes(regex: String): H2Reader = new H2Reader(url, user, pass, schema, excludes = Some(regex))
-
   protected def buildDatabase(columns: List[Column], crossReferences: List[CrossReference]): Database = {
     val refs = crossReferences.map(r => (Database.FieldRef(r.FKTABLE_SCHEMA, r.FKTABLE_NAME, r.FKCOLUMN_NAME), Database.FieldRef(r.PKTABLE_SCHEMA, r.PKTABLE_NAME, r.PKCOLUMN_NAME))).toMap
     Database(columns.groupBy(_.TABLE_SCHEMA).toList.sortBy(_._1).map { case (schema, tables) =>

src/main/scala/fr/loicknuchel/safeql/gen/writer/ScalaWriter.scala

@@ -8,18 +8,24 @@ import fr.loicknuchel.safeql.gen.writer.ScalaWriter.{DatabaseConfig, TableConfig
 import fr.loicknuchel.safeql.gen.writer.Writer.IdentifierStrategy
 import fr.loicknuchel.safeql.utils.StringUtils
 
-class ScalaWriter(directory: String,
-                  packageName: String,
-                  identifierStrategy: IdentifierStrategy,
-                  config: DatabaseConfig) extends Writer {
+class ScalaWriter(val directory: String,
+                  val packageName: String,
+                  val identifierStrategy: IdentifierStrategy,
+                  val config: DatabaseConfig) extends Writer {
   require(config.getConfigErrors.isEmpty, s"DatabaseConfig has some errors :${config.getConfigErrors.map("\n - " + _).mkString}")
   require(StringUtils.isScalaPackage(packageName), s"'$packageName' is an invalid scala package name")
 
   def directory(dir: String): ScalaWriter = new ScalaWriter(dir, packageName, identifierStrategy, config)
 
-  override protected def getDatabaseErrors(db: Database): List[String] = config.getDatabaseErrors(db)
+  def packageName(pkg: String): ScalaWriter = new ScalaWriter(directory, pkg, identifierStrategy, config)
 
-  override protected[gen] def rootFolderPath: String = directory + "/" + packageName.replaceAll("\\.", "/")
+  def identifierStrategy(idf: IdentifierStrategy): ScalaWriter = new ScalaWriter(directory, packageName, idf, config)
+
+  def config(conf: DatabaseConfig): ScalaWriter = new ScalaWriter(directory, packageName, identifierStrategy, conf)
+
+  override def getDatabaseErrors(db: Database): List[String] = config.getDatabaseErrors(db)
+
+  override def rootFolderPath: String = directory + "/" + packageName.replaceAll("\\.", "/")
 
   override protected[writer] def tableFilePath(t: Table): String = tablesFolderPath + "/" + idf(t.name) + ".scala"
 

src/main/scala/fr/loicknuchel/safeql/models/Page.scala

@@ -28,6 +28,10 @@ object Page {
     def filters(f: Map[String, String]): Params = copy(filters = f)
 
     def filters(f: (String, String)*): Params = filters(f.toMap)
+
+    def withNullsFirst: Params = copy(nullsFirst = true)
+
+    def withNullsLast: Params = copy(nullsFirst = false)
   }
 
 }

src/main/scala/fr/loicknuchel/safeql/utils/Extensions.scala

@@ -13,7 +13,7 @@ import scala.collection.mutable
 import scala.util.control.NonFatal
 import scala.util.{Failure, Success, Try}
 
-object Extensions {
+private[safeql] object Extensions {
 
   implicit class RichOption[A](val in: Option[A]) extends AnyVal {
     def toEither[E](e: => E): Either[E, A] = in match {

src/main/scala/fr/loicknuchel/safeql/utils/FileUtils.scala

@@ -3,10 +3,12 @@ package fr.loicknuchel.safeql.utils
 import java.io.File
 import java.nio.file.{Files, Paths}
 
+import fr.loicknuchel.safeql.utils.Extensions._
+
 import scala.jdk.CollectionConverters._
 import scala.util.Try
 
-object FileUtils {
+private[safeql] object FileUtils {
   def parent(path: String): String =
     path.split("/").dropRight(1).mkString("/")
 
@@ -22,6 +24,13 @@ object FileUtils {
     listDir(new File(path)).filter(_.isFile).map(_.getPath).sorted
   }
 
+  // return a map for files with their relative path inside the directory and their content
+  def getDirContent(path: String): Try[Map[String, String]] = {
+    FileUtils.listFiles(path)
+      .flatMap(_.map(p => FileUtils.read(p).map(c => (p.stripPrefix(path + "/"), c))).sequence)
+      .map(_.toMap)
+  }
+
   def read(path: String): Try[String] =
     Try(Files.readAllLines(Paths.get(path))).map(_.asScala.mkString("\n"))
 

src/main/scala/fr/loicknuchel/safeql/utils/StringUtils.scala

@@ -2,7 +2,7 @@ package fr.loicknuchel.safeql.utils
 
 import java.text.Normalizer
 
-object StringUtils {
+private[safeql] object StringUtils {
   def removeDiacritics(str: String): String =
     Normalizer.normalize(str, Normalizer.Form.NFD)
       .replaceAll("\\p{InCombiningDiacriticalMarks}+", "")

src/test/scala/fr/loicknuchel/safeql/gen/GeneratorSpec.scala

@@ -2,82 +2,52 @@ package fr.loicknuchel.safeql.gen
 
 import java.util.UUID
 
-import cats.data.NonEmptyList
 import fr.loicknuchel.safeql.gen.reader.H2Reader
-import fr.loicknuchel.safeql.gen.writer.ScalaWriter.{DatabaseConfig, FieldConfig, SchemaConfig, TableConfig}
-import fr.loicknuchel.safeql.gen.writer.{ScalaWriter, Writer}
-import fr.loicknuchel.safeql.testingutils.BaseSpec
-import fr.loicknuchel.safeql.utils.Extensions._
+import fr.loicknuchel.safeql.testingutils.{BaseSpec, CLI}
 import fr.loicknuchel.safeql.utils.FileUtils
 import org.flywaydb.core.Flyway
 import org.flywaydb.core.internal.jdbc.DriverDataSource
 import org.scalatest.BeforeAndAfterEach
 
-import scala.util.Try
-
 class GeneratorSpec extends BaseSpec with BeforeAndAfterEach {
-  private val root = "target/tmp-generator-tests"
-  private val reader = H2Reader(
-    url = s"jdbc:h2:mem:${UUID.randomUUID()};MODE=PostgreSQL;DATABASE_TO_UPPER=false;DB_CLOSE_DELAY=-1",
-    schema = Some("PUBLIC"),
-    excludes = Some(".*flyway.*"))
-  private val writer = ScalaWriter(
-    directory = "src/test/scala",
-    packageName = "fr.loicknuchel.safeql.testingutils.database",
-    identifierStrategy = Writer.IdentifierStrategy.upperCase,
-    config = DatabaseConfig(
-      scaladoc = _ => Some("Hello"),
-      imports = List("fr.loicknuchel.safeql.testingutils.Entities._"),
-      schemas = Map("PUBLIC" -> SchemaConfig(tables = Map(
-        "users" -> TableConfig(alias = Some("u"), fields = Map(
-          "id" -> FieldConfig(customType = Some("User.Id")))),
-        "categories" -> TableConfig(alias = "c", sort = TableConfig.Sort("name", NonEmptyList.of("-name", "id")), search = List("name"), fields = Map(
-          "id" -> FieldConfig(customType = Some("Category.Id")))),
-        "posts" -> TableConfig(alias = Some("p"), fields = Map(
-          "id" -> FieldConfig(customType = Some("Post.Id"))))
-      )))))
+  private val root = "target/tests-generator"
 
   override protected def afterEach(): Unit = FileUtils.delete(root).get
 
   describe("Generator") {
     it("should generate the same files with all the generators") {
       // Basic generation
+      val reader = H2Reader(
+        url = s"jdbc:h2:mem:${UUID.randomUUID()};MODE=PostgreSQL;DATABASE_TO_UPPER=false;DB_CLOSE_DELAY=-1",
+        schema = Some("PUBLIC"),
+        excludes = Some(".*flyway.*"))
       Flyway.configure()
         .dataSource(new DriverDataSource(this.getClass.getClassLoader, reader.driver, reader.url, reader.user, reader.pass))
         .locations("classpath:sql_migrations")
         .load().migrate()
       val basicPath = s"$root/basic-gen"
-      Generator.reader(reader).writer(writer.directory(basicPath)).generate().unsafeRunSync()
-      val basicDb = getFolderContent(basicPath).get
+      Generator.reader(reader).writer(CLI.GenerateSampleDatabase.writer.directory(basicPath)).generate().unsafeRunSync()
+      val basicDb = FileUtils.getDirContent(basicPath).get
 
       // Flyway generator
       val flywapPath = s"$root/flyway-gen"
-      Generator.flyway("classpath:sql_migrations").writer(writer.directory(flywapPath)).generate().unsafeRunSync()
-      val flywayDb = getFolderContent(flywapPath).get
+      Generator.flyway("classpath:sql_migrations").writer(CLI.GenerateSampleDatabase.writer.directory(flywapPath)).generate().unsafeRunSync()
+      val flywayDb = FileUtils.getDirContent(flywapPath).get
       flywayDb shouldBe basicDb
 
       // SQL files generator
       val sqlFilesPath = s"$root/sql-gen"
-      Generator.fromFiles(List("src/test/resources/sql_migrations/V1__test_schema.sql")).writer(writer.directory(sqlFilesPath)).generate().unsafeRunSync()
-      val sqlFilesDb = getFolderContent(sqlFilesPath).get
+      Generator.fromFiles(List("src/test/resources/sql_migrations/V1__test_schema.sql")).writer(CLI.GenerateSampleDatabase.writer.directory(sqlFilesPath)).generate().unsafeRunSync()
+      val sqlFilesDb = FileUtils.getDirContent(sqlFilesPath).get
       sqlFilesDb shouldBe basicDb
     }
     it("should keep the generated database up to date") {
-      val flywayWriter = writer.directory(s"$root/flyway-gen")
+      val flywayWriter = CLI.GenerateSampleDatabase.writer.directory(s"$root/flyway-gen")
       Generator.flyway("classpath:sql_migrations").writer(flywayWriter).generate().unsafeRunSync()
 
-      val flywayDb = getFolderContent(flywayWriter.rootFolderPath).get
-      val currentDb = getFolderContent(writer.rootFolderPath).get
+      val flywayDb = FileUtils.getDirContent(flywayWriter.rootFolderPath).get
+      val currentDb = FileUtils.getDirContent(CLI.GenerateSampleDatabase.writer.rootFolderPath).get
       currentDb shouldBe flywayDb
     }
-    ignore("should generate the database tables") { // run this test to generate the test database tables
-      Generator.reader(reader).writer(writer).generate().unsafeRunSync()
-    }
-  }
-
-  private def getFolderContent(path: String): Try[Map[String, String]] = {
-    FileUtils.listFiles(path)
-      .flatMap(_.map(p => FileUtils.read(p).map(c => (p.stripPrefix(path), c))).sequence)
-      .map(_.toMap)
   }
 }

src/test/scala/fr/loicknuchel/safeql/models/ExceptionsSpec.scala

@@ -0,0 +1,20 @@
+package fr.loicknuchel.safeql.models
+
+import fr.loicknuchel.safeql.testingutils.BaseSpec
+
+class ExceptionsSpec extends BaseSpec {
+  private val e1 = new Exception("an error")
+  private val e2 = new Exception("an other error")
+  private val m = MultiException(e1, e2)
+
+  describe("Exceptions") {
+    describe("MultiException") {
+      it("should carry multiple exceptions") {
+        m.getMessage shouldBe "\n  - an error\n  - an other error"
+        m.getLocalizedMessage shouldBe "\n  - an error\n  - an other error"
+        m.getStackTrace shouldBe e1.getStackTrace
+        m.getCause shouldBe e1.getCause
+      }
+    }
+  }
+}

src/test/scala/fr/loicknuchel/safeql/models/PageSpec.scala

@@ -0,0 +1,43 @@
+package fr.loicknuchel.safeql.models
+
+import fr.loicknuchel.safeql.testingutils.BaseSpec
+
+class PageSpec extends BaseSpec {
+  describe("Page") {
+    describe("Params") {
+      it("should have all default values") {
+        Page.Params().page shouldBe 1 // testing the empty constructor
+      }
+      it("should have setters") {
+        val p = Page.Params()
+
+        p.page shouldBe 1
+        p.page(2).page shouldBe 2
+
+        p.pageSize shouldBe 20
+        p.pageSize(2).pageSize shouldBe 2
+
+        p.search shouldBe None
+        p.search("q").search shouldBe Some("q")
+
+        p.orderBy shouldBe List()
+        p.orderBy("name,date", "score").orderBy shouldBe List("name", "date", "score")
+
+        p.filters shouldBe Map()
+        p.filters("type" -> "meetup", "future" -> "true").filters shouldBe Map("type" -> "meetup", "future" -> "true")
+
+        p.nullsFirst shouldBe false
+        p.withNullsFirst.nullsFirst shouldBe true
+      }
+      it("should clean arguments on orderBy setter") {
+        val p = Page.Params()
+        p.orderBy("a,,b ,c", "d,e").orderBy shouldBe List("a", "b", "c", "d", "e")
+      }
+      it("should update order by only when empty") {
+        val p = Page.Params()
+        p.defaultOrderBy("b").orderBy shouldBe List("b")
+        p.orderBy("a").defaultOrderBy("b").orderBy shouldBe List("a")
+      }
+    }
+  }
+}

src/test/scala/fr/loicknuchel/safeql/testingutils/CLI.scala

@@ -0,0 +1,37 @@
+package fr.loicknuchel.safeql.testingutils
+
+import cats.data.NonEmptyList
+import cats.effect.IO
+import fr.loicknuchel.safeql.gen.Generator
+import fr.loicknuchel.safeql.gen.writer.ScalaWriter.{DatabaseConfig, FieldConfig, SchemaConfig, TableConfig}
+import fr.loicknuchel.safeql.gen.writer.{ScalaWriter, Writer}
+
+object CLI {
+  def main(args: Array[String]): Unit = {
+    GenerateSampleDatabase.run().unsafeRunSync()
+    println("Done")
+  }
+
+  object GenerateSampleDatabase {
+    val writer: ScalaWriter = ScalaWriter(
+      directory = "src/test/scala",
+      packageName = "fr.loicknuchel.safeql.testingutils.database",
+      identifierStrategy = Writer.IdentifierStrategy.upperCase,
+      config = DatabaseConfig(
+        scaladoc = _ => Some("Hello"),
+        imports = List("fr.loicknuchel.safeql.testingutils.Entities._"),
+        schemas = Map("PUBLIC" -> SchemaConfig(tables = Map(
+          "users" -> TableConfig(alias = Some("u"), fields = Map(
+            "id" -> FieldConfig(customType = Some("User.Id")))),
+          "categories" -> TableConfig(alias = "c", sort = TableConfig.Sort("name", NonEmptyList.of("-name", "id")), search = List("name"), fields = Map(
+            "id" -> FieldConfig(customType = Some("Category.Id")))),
+          "posts" -> TableConfig(alias = Some("p"), fields = Map(
+            "id" -> FieldConfig(customType = Some("Post.Id"))))
+        )))))
+
+    def run(): IO[Unit] = {
+      Generator.flyway("classpath:sql_migrations").writer(writer).generate()
+    }
+  }
+
+}

src/test/scala/fr/loicknuchel/safeql/utils/FileUtilsSpec.scala

@@ -4,7 +4,7 @@ import fr.loicknuchel.safeql.testingutils.BaseSpec
 import org.scalatest.BeforeAndAfterEach
 
 class FileUtilsSpec extends BaseSpec with BeforeAndAfterEach {
-  private val root = "target/file-utils-tests"
+  private val root = "target/tests-file-utils"
 
   override protected def beforeEach(): Unit = FileUtils.mkdirs(root).get
 
@@ -35,5 +35,14 @@ class FileUtilsSpec extends BaseSpec with BeforeAndAfterEach {
       FileUtils.delete(s"$root/src").get
       an[Exception] should be thrownBy FileUtils.read(s"$root/src/test/scala/fr/lkn/main.scala").get
     }
+    it("should list folder content") {
+      FileUtils.mkdirs(s"$root/src/main/scala/fr/loicknuchel").get
+      FileUtils.write(s"$root/src/main/scala/fr/loicknuchel/Main.scala", "public class Main").get
+      FileUtils.write(s"$root/src/main/scala/README.md", "The readme").get
+
+      FileUtils.getDirContent(s"$root/src/main/scala").get shouldBe Map(
+        "README.md" -> "The readme",
+        "fr/loicknuchel/Main.scala" -> "public class Main")
+    }
   }
 }