init

Author: Bunyod Bobojonov

.gitignore

@@ -0,0 +1,9 @@
+.history
+.idea
+*.iml
+out
+*.ipr
+*.iws
+target
+.sonarwork
+*.log

.pre-commit-config.yaml

@@ -0,0 +1,23 @@
+repos:
+    -   repo: https://github.com/pre-commit/pre-commit-hooks
+        rev: v2.0.0
+        hooks:
+            -   id: check-json
+            -   id: check-merge-conflict
+            -   id: check-xml
+            -   id: check-yaml
+            -   id: detect-private-key
+    -   repo: [email protected]:coyainsurance/pre-commit-scalafmt.git
+        sha: master
+        hooks:
+            - id: scalafmt
+              args: [-t ]
+
+    -   repo: local
+        hooks:
+            -   id: scalastyle
+                name: scalastyle
+                entry: scalastyle --config scalastyle-config.xml
+                language: system
+                files: \.(scala|sbt)$
+                types: [file, text]

.scalafmt.conf

@@ -0,0 +1,49 @@
+version=2.0.0-RC8
+style = defaultWithAlign
+maxColumn = 120
+lineEndings = unix
+importSelectors = singleLine
+docstrings = ScalaDoc
+
+project {
+  git = true
+}
+
+align = none
+
+align {
+  tokens = [ {code = "=>", owner = "Case|Type.Arg.ByName"}, "<-", "->", "%", "%%" ]
+  arrowEnumeratorGenerator = true
+  openParenCallSite = false
+  openParenDefnSite = false
+}
+
+binPack {
+  parentConstructors = true
+}
+
+continuationIndent {
+  callSite = 2
+  defnSite = 2
+}
+
+newlines {
+  penalizeSingleSelectMultiArgList = false
+  sometimesBeforeColonInMethodReturnType = true
+}
+
+rewrite {
+  rules = [RedundantBraces, RedundantParens, AsciiSortImports]
+  redundantBraces {
+    maxLines = 100
+    includeUnitMethods = true
+    stringInterpolation = true
+  }
+}
+
+spaces {
+  inImportCurlyBraces = false
+  beforeContextBoundColon = false
+}
+
+assumeStandardLibraryStripMargin = true

Dockerfile

@@ -0,0 +1,13 @@
+FROM 'hseeberger/scala-sbt:11.0.1_2.12.8_1.2.8' as build-env
+LABEL image=build-env
+ENV SONAR_SCANNER_VERSION 3.3.0.1492
+
+ENV SONAR_RUNNER_HOME=/root/sonar_home
+COPY . /root
+# Add sonarScan to build step
+#RUN sbt scalastyle scapegoat coverage test coverageReport coverageOff scala213/assembly
+RUN sbt compile test:compile scala213/assembly
+FROM openjdk:8u181-slim as scala213-prod
+RUN mkdir -p /opt/scala-service
+COPY --from=build-env A B
+CMD ["java","-jar", "-Dconfig.resource=prod/application.conf", "/opt/scala-service/scala213-0.1.jar"]

Jenkinsfile

@@ -0,0 +1,67 @@
+pipeline {
+	agent {
+		label 'connectivity'
+	}
+	stages {
+			stage('Build image') {
+    			steps {
+    				sh "docker image build --target build-env -t scala213-dev:${BUILD_NUMBER} ."
+    			}
+    		}
+		stage('Code analysis') {
+				steps {
+				    sh 'docker run --rm -v sbt-dev:/root scala213-dev:${BUILD_NUMBER} sbt scalastyle scapegoat'
+			}
+		}
+		stage('Test Unit') {
+				steps {
+				    sh 'docker run --rm -v sbt-dev:/root scala213-dev:${BUILD_NUMBER} sbt coverage test coverageReport'
+			}
+		}
+		stage('Create production image') {
+                when {
+                    anyOf {
+                        branch 'master'; branch 'refactoring'
+                    }
+                }
+				steps {
+				    sh "docker image build -t docker.bunic.de:5001/scala213:${BUILD_NUMBER} ."
+                    sh "docker push docker.bunic.de:5001/scala213:${BUILD_NUMBER}"
+			}
+		}
+		stage('Deploy Stage') {
+		        when {
+                    anyOf {
+                        branch 'master';
+                    }
+                }
+			steps {
+				sh 'echo  \'{ \
+                        "container": { \
+                          "type": "DOCKER", \
+                          "docker": { \
+                            "image": "docker.bunic.de:5001/sscala213:\'$BUILD_NUMBER\'", \
+                            "network": "BRIDGE", \
+                            "portMappings": [ \
+                              { \
+                                "containerPort": 8080, \
+                                "hostPort": 0, \
+                                "protocol": "tcp" \
+                              } \
+                            ] \
+                          } \
+                        } \
+                      }\' | docker run -i k0pernikus/httpie-docker-alpine:1.0.0 PUT http://bunic.de/marathon/v2/apps/seed'
+			}
+		}
+		stage('Deploy Production') {
+			input {
+				message "Deploy to production?"
+					id "simple-input"
+			}
+			steps {
+				echo 'deploy production'
+			}
+		}
+	}
+}

LICENSE

@@ -0,0 +1,13 @@
+This software is licensed under the Apache 2 license, quoted below.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not
+use this file except in compliance with the License. You may obtain a copy of
+the License at
+
+    [http://www.apache.org/licenses/LICENSE-2.0]
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations under
+the License.

README.md

@@ -0,0 +1,189 @@
+Scala 2.13 Project
+=============================
+
+## Goal
+The goal for this project is to demonstrate how to start easily a new scala 2.13 project (using FP techniques? :) ).
+
+## Stack technologies
+
+- [JDK 8](http://www.oracle.com/technetwork/java/javase/downloads/index.html)
+- [SBT](http://www.scala-sbt.org/release/docs/Getting-Started/Setup.html)
+- [akka-http](https://doc.akka.io/docs/akka-http/current/) as the web server. I could have gone with finch, twitter server, or http4s here as well.
+- [Circe](https://circe.github.io/circe/) for json serialization
+- [Cats](https://typelevel.org/cats/) for FP awesomeness
+- [Scapegoat](https://github.com/sksamuel/scapegoat) for linting
+- [ScalaTest](http://www.scalatest.org/) for test  
+
+## Architecture
+### Domain Driven Design (DDD)
+Domain driven design is all about developing a _ubiquitous language_, which is a language that you can use to discuss your software with business folks (who presumably do not know programming).
+
+DDD is all about making your code expressive, making sure that how you _talk_ about your software materializes in your code.  One of the best ways to do this is to keep you _domain_ pure.  That is, allow the business concepts and entities to be real things, and keep all the other cruft out.  However, HTTP, JDBC, SQL are not essential to domain, so we want to _decouple_ those as much as possible.
+
+### Onion (or Hexagonal) Architecture
+In concert with DDD, the [Onion Architecture](https://jeffreypalermo.com/2008/08/the-onion-architecture-part-3/) and [Hexagonal Architecture from Cockburn](https://java-design-patterns.com/patterns/hexagonal/) give us patterns on how to separate our domain from the ugliness of implementation.
+
+We fit DDD an Onion together via the following mechanisms:
+
+**The domain package**
+The domain package constitutes the things inside our domain.  It is deliberately free of the ugliness of JDBC, JSON, HTTP, and the rest. 
+We use `Services` as coarse-grained interfaces to our domain.  These typically represent real-world use cases. Often times, you see a 1-to-1 mapping of `Services` to `R` or HTTP API calls your application surfaces.
+
+Inside of the **domain**, we see a few concepts:
+
+1. `Service` - the coarse grained use cases that work with other domain concepts to realize your use-cases
+1. `Repository` - ways to get data into and out of persistent storage.  **Important: Repositories do not have any business logic in them, they should not know about the context in which they are used, and should not leak details of their implementations into the world**.
+1. `payloads` or `models` - things like `Tweet`, etc are all domain objects.  We keep these lean (i.e. free of behavior).
+
+**The repository package**
+The repository package is where the ugliness lives.  It has JDBC things, and the like.
+it contains implementations of our `Repositories`.  We may have 2 different implementations, an in-memory version as well as a **doobie** version.
+
+**The http package**
+It contains the HTTP endpoints that we surface via **akka-http**.  You will also typically see JSON things in here via **circe**
+
+**The util package**
+The util package could be considered infrastructure, as it has nothing to do with the domain.
+
+**NOTE**
+All business logic is located in `domain` package, every package inside is
+related to some domain.
+
+Service classes contains high level logic that relate to data manipulation,
+that means that services MUST NOT implement storage.
+
+For storage there are dedicated classes.
+
+## Conventions
+
+## Versioning
+
+## Database
+
+## Configuration
+1.`application.conf`
+1.`stage.application.conf`
+1.`prod.application.conf`
+We use **Pure Config** to load configuration objects when the application starts up.  **pure config** Provides a neat mapping of config file to case classes for us, so we really do not have to do any code.
+
+## Run
+
+To run project locally and load the corresponding secretes, it is recommended to
+choose one of the following alternatives.
+
+## Command line
+
+In order to run locally on a developer machine via the command line, go to
+source folder and execute
+
+```
+~/scala213/> sbt runServer
+```
+
+For `<command>` use one of `~compile | test | run`
+
+## IntelliJ
+FIXME
+1. Open settings (`File -> Settings or CTRL+ALT+S`)
+1. Choose Plugins
+1. Open "browse repositories" window and type `BashSupport`
+1. Click "Install" button and wait until the installation completes
+1. Restart Intellij IDEA
+1. Open Run/Debug Configuration (`Run -> Edit Configurations`)
+1. Click "+" button and select "Bash" item from drop down
+1. Give a name and select `sbt` file from source code
+1. Enter `run` into "Program arguments" field
+1. Click "Apply" and "OK"
+1. Click green button on the right side at the top of the window (or `Shift+F10`)
+
+## Testing
+
+```
+```
+
+## Pre-Commit Hook
+
+[Pre Commit](https://github.com/pre-commit/pre-commit) is a project on github to setup and maintain
+git commit hooks. The default hooks are defined in `.pre-commit-config.yaml`
+
+For installation on osx run
+
+```
+brew install pre-commit
+```
+
+To setup the hooks with pre-commit run:
+
+```
+pre-commit install -f --install-hooks
+```
+
+After that scalafmt checks your changed files for codestyle:
+
+_Note:_ Conflicts should be resolved 
+
+## Deployment
+
+This section describes how to deploy `scala213` to either `STAGE` or `PROD`.
+
+## Dependency Udpates
+
+```
+sbt dependencyUpdates
+```
+
+Lists newer versions of integrated dependencies from Maven/Ivy
+
+sbt dependencyUpdates
+
+## Linting
+
+Linting is done via scapegoat. It is a static code analyzer inspecting the code with a set of 117 rules.
+Certain files can be excluded, rules can be changed. Configuration is described [here](https://github.com/sksamuel/scapegoat).
+
+The report can be picked up by Jenkins and should be part of the deployment pipeline.
+
+## Publish
+
+Not to be confused with Sbt's "publishing"!.
+
+```
+haha FIXME
+```
+
+## Release
+
+```
+haha FIXME
+```
+
+## Resources
+
+- For setting up the initial `seed` structure, we utilized
+  [Scala Pet Store](https://github.com/pauljamescleary/scala-pet-store).
+
+- For STAGE/ PROD configuration, we utilized [Production
+  Configuration](https://www.playframework.com/documentation/2.6.x/ProductionConfiguration#overriding-configuration-with-system-properties)
+
+## Known issues
+
+### Configuration via Pureconfig
+
+Pureconfig's config file does not support uppercase and underscores. [Read here](https://github.com/pureconfig/pureconfig/issues/394)
+
+### sbt-partial-unification
+In order to use cats...
+
+## How to use sbt-coverage
+
+Run the tests with enabled coverage:
+```
+$ sbt clean test
+```
+
+To generate the coverage reports run
+```
+$ sbt coverageReport
+```
+
+Coverage reports will be in target/scala-2.12/scoverage-report/index.html.

api/src/it/resources/application.conf

@@ -0,0 +1,13 @@
+http {
+  host = "0.0.0.0"
+  port = 8082
+}
+
+auth {
+  realm = "test"
+  secret = "test"
+}
+
+swagger {
+  host = "localhost:9000"
+}