Create CLI.

Author: olafurpg

Readme.md

@@ -1,4 +1,42 @@
-# db-codegen
+# scala-db-codegen
+
+Generate Scala code from your database.
+Only tested with postgresql, but could in theory work with any jdbc compliant database.
+
+## CLI
+
+```shell
+$ db-codegen --help
+db-codegen 0.1.0
+Usage: db-codegen [options]
+  --usage
+        Print usage and exit
+  --help | -h
+        Print help message and exit
+  --user  <value>
+        user on database server
+  --password  <value>
+        password for user on database server
+  --url  <value>
+        jdbc url
+  --schema  <value>
+        schema on database
+  --jdbc-driver  <value>
+        only tested with postgresql
+  --imports  <value>
+        top level imports of generated file
+  --package  <value>
+        package name for generated classes
+  --type-map  <value>
+        Which types should write to which types? Format is: numeric,BigDecimal;int8,Long;...
+  --excluded-tables  <value>
+        Do not generate classes for these tables.
+  --file  <value>
+        Write generated code to this filename. Prints to stdout if not set.
+```
+
+## Standalone library
+
+TODO, look at source for now.
+
 
-Generated "Type all the things" Scala code given a connection to a database.
-Only tested with postgresql.

build.sbt

@@ -33,17 +33,19 @@ lazy val publishSettings = Seq(
 
 lazy val `launaskil-codegen` =
   (project in file("."))
+    .settings(packSettings)
     .settings(publishSettings)
     .settings(
       name := "codegen",
       organization := "com.geirsson",
       scalaVersion := "2.11.8",
+      packMain := Map("db-codegen" -> "com.geirsson.codegen.Codegen"),
       libraryDependencies ++= Seq(
         "com.geirsson" %% "scalafmt-core" % "0.3.0",
         "io.getquill" %% "quill-core" % "0.8.0",
         "com.h2database" % "h2" % "1.4.192",
         "org.postgresql" % "postgresql" % "9.4-1201-jdbc41",
-        "com.github.alexarchambault" %% "case-app" % "1.1.0-RC3",
+        "com.github.alexarchambault" %% "case-app" % "1.0.0-RC3",
         "org.scalatest" %% "scalatest" % "3.0.0" % "test"
       )
     )

project/plugins.sbt

@@ -1,2 +1,3 @@
 addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "1.1")
 addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.0")
+addSbtPlugin("org.xerial.sbt" % "sbt-pack" % "0.8.0")

src/main/scala/com/geirsson/codegen/Codegen.scala

@@ -8,13 +8,47 @@ import java.sql.Connection
 import java.sql.DriverManager
 import java.sql.ResultSet
 
+import caseapp.AppOf
+import caseapp._
 import io.getquill.NamingStrategy
 import org.scalafmt.FormatResult
 import org.scalafmt.Scalafmt
 import org.scalafmt.ScalafmtStyle
 
-case class Codegen(options: CodegenOptions, namingStrategy: NamingStrategy) {
+case class Error(msg: String) extends Exception(msg)
+
+@AppName("db-codegen")
+@AppVersion("0.1.0")
+@ProgName("db-codegen")
+case class CodegenOptions(
+    @HelpMessage("user on database server") user: String = "postgres",
+    @HelpMessage("password for user on database server") password: String =
+      "postgres",
+    @HelpMessage("jdbc url") url: String = "jdbc:postgresql:postgres",
+    @HelpMessage("schema on database") schema: String = "public",
+    @HelpMessage("only tested with postgresql") jdbcDriver: String =
+      "org.postgresql.Driver",
+    @HelpMessage(
+      "top level imports of generated file"
+    ) imports: String = """|import java.util.Date
+                           |import io.getquill.WrappedValue""".stripMargin,
+    @HelpMessage(
+      "package name for generated classes"
+    ) `package`: String = "tables",
+    @HelpMessage(
+      "Which types should write to which types? Format is: numeric,BigDecimal;int8,Long;..."
+    ) typeMap: TypeMap = TypeMap.default,
+    @HelpMessage(
+      "Do not generate classes for these tables."
+    ) excludedTables: List[String] = List("schema_version"),
+    @HelpMessage(
+      "Write generated code to this filename. Prints to stdout if not set."
+    ) file: Option[String] = None
+) extends App {
+  Codegen.cliRun(this)
+}
 
+case class Codegen(options: CodegenOptions, namingStrategy: NamingStrategy) {
   import Codegen._
   val excludedTables = options.excludedTables.toSet
   val columnType2scalaType = options.typeMap.pairs.toMap
@@ -112,7 +146,9 @@ case class Codegen(options: CodegenOptions, namingStrategy: NamingStrategy) {
                     nullable: Boolean,
                     isPrimaryKey: Boolean,
                     references: Option[SimpleColumn]) {
-    val scalaType = columnType2scalaType(`type`)
+    val scalaType = columnType2scalaType.getOrElse(`type`, {
+      throw Error(s"ERROR: missing --type-map for type '${`type`}'")
+    })
 
     def toArg(namingStrategy: NamingStrategy, tableName: String): String = {
       s"${namingStrategy.column(columnName)}: ${this.toSimple.toType}"
@@ -154,10 +190,9 @@ case class Codegen(options: CodegenOptions, namingStrategy: NamingStrategy) {
           |}""".stripMargin
     }
   }
-
 }
 
-object Codegen {
+object Codegen extends AppOf[CodegenOptions] {
   val TABLE_NAME = "TABLE_NAME"
   val COLUMN_NAME = "COLUMN_NAME"
   val TYPE_NAME = "TYPE_NAME"
@@ -174,23 +209,26 @@ object Codegen {
     }
   }
 
-  import caseapp._
-
-  def main(args: Array[String]): Unit = {
-    CaseApp.parse[CodegenOptions](args) match {
-      case Right((options, _)) => run(options)
-      case Left(msg) => System.err.println(msg)
+  def cliRun(codegenOptions: CodegenOptions,
+             outstream: PrintStream = System.out): Unit = {
+    try {
+      run(codegenOptions, outstream)
+    } catch {
+      case Error(msg) =>
+        System.err.println(msg)
+        System.exit(1)
     }
   }
 
   def run(codegenOptions: CodegenOptions,
           outstream: PrintStream = System.out): Unit = {
     println("Starting...")
+
     val startTime = System.currentTimeMillis()
     Class.forName(codegenOptions.jdbcDriver)
     val db: Connection =
       DriverManager.getConnection(codegenOptions.url,
-                                  codegenOptions.username,
+                                  codegenOptions.user,
                                   codegenOptions.password)
     val codegen = Codegen(codegenOptions, SnakeCaseReverse)
     val foreignKeys = codegen.getForeignKeys(db)

src/main/scala/com/geirsson/codegen/CodegenOptions.scala

@@ -9,7 +9,7 @@ object TypeMap {
     ArgParser.instance[TypeMap] { s =>
       try {
         val pairs = s.split(";").map { pair =>
-          val from :: to :: Nil = pair.split(",", 1).toList
+          val from :: to :: Nil = pair.split(",", 2).toList
           from -> to
         }
         Right(TypeMap(pairs: _*))

src/main/scala/com/geirsson/codegen/TypeMap.scala

@@ -5,6 +5,7 @@ import java.io.PrintStream
 import java.nio.charset.StandardCharsets
 import java.sql.DriverManager
 
+import caseapp.CaseApp
 import org.scalatest.FunSuite
 
 class CodegenTest extends FunSuite {
@@ -14,14 +15,24 @@ class CodegenTest extends FunSuite {
     code.parse[Source].get.structure
   }
 
+  test("--type-map") {
+    val obtained =
+      CaseApp.parse[CodegenOptions](
+        Seq("--type-map", "numeric,BigDecimal;int8,Long"))
+    val expected = Right(
+      (CodegenOptions(
+         typeMap = TypeMap("numeric" -> "BigDecimal", "int8" -> "Long")),
+       Seq.empty[String]))
+    assert(obtained === expected)
+  }
+
   test("testMain") {
     val options = CodegenOptions(
       `package` = "my.custom"
     )
     Class.forName(options.jdbcDriver)
     val conn =
-      DriverManager
-        .getConnection(options.url, options.username, options.password)
+      DriverManager.getConnection(options.url, options.user, options.password)
     val stmt = conn.createStatement()
     val sql =
       """