Merge pull request #5 from fractalliter/upgrade_dependencies

Upgrade dependencies

Author: fractalliter

.env-example

@@ -0,0 +1,20 @@
+WEB_PORT=8080
+WEB_DB_URL=jdbc:postgresql://db:5432
+WEB_DATABASE=personia
+WEB_DB_USERNAME=postgres
+WEB_DB_PASSWORD=postgres
+JWT_SECRET=secret
+JWT_ISSUER=http://0.0.0.0:8080/
+JWT_AUDIENCE=http://0.0.0.0:8080/hierarchy
+JWT_REALM=hierarchy
+JWT_EXPIRATION=31536000
+AUTH_DB_VENDOR=POSTGRES
+AUTH_DB_ADDRESS=auth-db
+AUTH_DB_DATABASE=keycloak
+AUTH_DB_USER=keycloak
+AUTH_DB_SCHEMA=public
+AUTH_DB_PASSWORD=password
+AUTH_SERVER_USER=manager
+AUTH_SERVER_PASSWORD=manager
+AUTH_ADMIN_USER=admin
+AUTH_ADMIN_PASSWORD=admin

.github/pull_request_template.md

@@ -0,0 +1,21 @@
+### All Submissions:
+
+- [ ] The commit message follows our guidelines
+- [ ] Tests for the changes have been added (for bug fixes/features)
+- [ ] Docs have been added / updated (for bug fixes / features)
+
+<!-- You can erase any parts of this template not applicable to your Pull Request. -->
+
+### How to test
+<!-- Add description about the tests -->
+
+### New Feature Submissions:
+
+1. [ ] Does your submission pass tests?
+2. [ ] Have you cleaned up your code locally before submission?
+
+### Changes to Core Features:
+
+* [ ] Have you added an explanation of what your changes do and why you'd like us to include them?
+* [ ] Have you written new tests for your core changes, as applicable?
+* [ ] Have you successfully run tests with your changes locally?

README.md

@@ -1,74 +1,87 @@
-# Kotlin-Ktor and postgres backend
-
-## Introduction
-
-Here lays a demonstration of my growing interest in Kotlin language and Ktor server framework. It's an example with
-complex Graph algorithms.
+# Kotlin Ktor and postgres backend
+Here lays a Kotlin web project with Ktor framework, Postgres database, and JWT Authentication.
+
+The project comprises following ingredients:
+- [Ktor](https://ktor.io/) server includes [JSON serializers](https://ktor.io/docs/serialization.html), [Authentication](https://ktor.io/docs/authentication.html), and [Testing](https://ktor.io/docs/testing.html)
+- [Netty](https://netty.io/) web server
+- [Postgres](https://www.postgresql.org/) as database
+- [Exposed](https://github.com/JetBrains/Exposed) as ORM
+- [Hikari Connection Pool](https://github.com/brettwooldridge/HikariCP)
+- [Logback](https://logback.qos.ch/) for logging purposes
+- [JBCrypt](https://www.mindrot.org/projects/jBCrypt/) for hashing passwords(No salting yet)
+
+There is a simple implementation of Graph search and traverse with DFS algorithm but if you aim for a solid solution
+better go for [GUAVA Graph](https://github.com/google/guava/wiki/GraphsExplained) from Google.
+
+Project is agnostic about database, you can dynamically change Postgres to any other databases that Exposed JDBC
+supports by changing a couple of variables:
+- the database driver version in `gradle.properties`
+- the database driver dependency in `build.gradle.kts`
+- the **WEB_DB_URL** variable in `.env` file
 
 ## Flow
+1. deploy the docker compose with `docker compose up -d` command
+2. sign up to the system `/signup` with a username and password(not hardened enough)
+3. log in to with username and password to get access token `/login`
+4. send post request with payload and token to `/hirearchy` to create the hierarchy of the organization
+5. send get request with token to `/hierarchy/{name}/supervisors` to fetch the supervisors of the current user
 
-To start the application you need to:
-
-1. deploy the docker compose
-2. sign up to the system `/signup`
-3. log in to get access token `/login`
-4. send post request with token to `/hirearchy` to create the hierarchy of the organization
-5. send post request with token to `/hierarchy/{name}/supervisors` to get the supervisors of the user
+## How to use
 
-## Starting the application
+> You need **root access** for docker
 
-Go to the root directory of the project and deploy the application with following command:
+Go to the root directory of the project where `docker-compose.yml` is and change the environment variables in
+`.env-example` with yours and rename the file to `mv .env-example .env` then deploy the application with following command:
 
 ```bash
 docker-compose up
 ```
 
-for shutting down the deployment:
+for shutting down the deployment run following command where the `docker-compose.yml` file resides:
 
 ```bash
 docker-compose down -v
 ```
 
-You might need root user access as well
-
 ### What it does?
 
-We have REST API to post the JSON below. This JSON represents an Person -> Person relationship that looks like this:
+We have REST API to post the JSON below. This JSON represents a Person -> Person relationship that looks like this:
 
-   ```json   
-   {
+```json   
+{
   "Pete": "Nick",
   "Barbara": "Nick",
   "Nick": "Sophie",
   "Sophie": "Jonas"
 }
-   ```
+```
 
 In this case, Nick is a supervisor of Pete and Barbara, Sophie supervises Nick. The supervisor list is
 not always in order.
 
-   ```bash
-      curl --request POST -sLv \
-           --url 'http://localhost:3000/hierarchy' \
-           --header "Content-Type: application/json" \
-           --header "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJodHRwOi8vMC4wLjAuMDo4MDgwL2hpZXJhcmNoeSIsImlzcyI6Imh0dHA6Ly8wLjAuMC4wOjgwODAvIiwiZXhwIjoxNjUwNDkwNzUwLCJ1c2VybmFtZSI6ImphbmUifQ.Xfn4JEOHo-Px7vy0TVyo3malCFlj3eFvzAJejqlefPM" \
-           --data '{"Nick":"Barbara","Barbara":"Nick","Elias":"Levi"}'
-   ```
+```bash
+curl --request POST -sLv \
+    --url 'http://localhost:3000/hierarchy' \
+    --header "Content-Type: application/json" \
+    --header "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJodHRwOi8vMC4wLjAuMDo4MDgwL2hpZXJhcmNoeSIsImlzcyI6Imh0dHA6Ly8wLjAuMC4wOjgwODAvIiwiZXhwIjoxNjUwNDkwNzUwLCJ1c2VybmFtZSI6ImphbmUifQ.Xfn4JEOHo-Px7vy0TVyo3malCFlj3eFvzAJejqlefPM" \
+    --data '{"Nick":"Barbara","Barbara":"Nick","Elias":"Levi"}'
+   
+```
 
 The response to querying the endpoint where the root is at the top of the JSON nested dictionary. For instance, previous
 input would result in:
 
 ```bash
-      curl --request GET -sLv \
-           --url 'http://localhost:3000/hierarchy' \
-           --header "Content-Type: application/json" \
-           --header "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJodHRwOi8vMC4wLjAuMDo4MDgwL2hpZXJhcmNoeSIsImlzcyI6Imh0dHA6Ly8wLjAuMC4wOjgwODAvIiwiZXhwIjoxNjUwNDkwNzUwLCJ1c2VybmFtZSI6ImphbmUifQ.Xfn4JEOHo-Px7vy0TVyo3malCFlj3eFvzAJejqlefPM"
-   ```
+curl --request GET -sLv \
+    --url 'http://localhost:3000/hierarchy' \
+    --header "Content-Type: application/json" \
+    --header "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJodHRwOi8vMC4wLjAuMDo4MDgwL2hpZXJhcmNoeSIsImlzcyI6Imh0dHA6Ly8wLjAuMC4wOjgwODAvIiwiZXhwIjoxNjUwNDkwNzUwLCJ1c2VybmFtZSI6ImphbmUifQ.Xfn4JEOHo-Px7vy0TVyo3malCFlj3eFvzAJejqlefPM"
+```
 
 the response will be:
 
-   ```json
-   {
+```json
+{
   "Jonas": {
     "Sophie": {
       "Nick": {
@@ -78,28 +91,28 @@ the response will be:
     }
   }
 }
-   ```
+```
 
 Query for a specific Person it's the hierarchy:
 
-   ```bash
-   curl --request GET -sLv \
-        --url 'http://localhost:3000/hierarchy/Nick/supervisors'\
-        --header "Content-Type: application/json" \
-        --header "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJodHRwOi8vMC4wLjAuMDo4MDgwL2hpZXJhcmNoeSIsImlzcyI6Imh0dHA6Ly8wLjAuMC4wOjgwODAvIiwiZXhwIjoxNjUwNDkwNzUwLCJ1c2VybmFtZSI6ImphbmUifQ.Xfn4JEOHo-Px7vy0TVyo3malCFlj3eFvzAJejqlefPM"
-   ```
+```bash
+curl --request GET -sLv \
+    --url 'http://localhost:3000/hierarchy/Nick/supervisors'\
+    --header "Content-Type: application/json" \
+    --header "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJodHRwOi8vMC4wLjAuMDo4MDgwL2hpZXJhcmNoeSIsImlzcyI6Imh0dHA6Ly8wLjAuMC4wOjgwODAvIiwiZXhwIjoxNjUwNDkwNzUwLCJ1c2VybmFtZSI6ImphbmUifQ.Xfn4JEOHo-Px7vy0TVyo3malCFlj3eFvzAJejqlefPM"
+```
 
 the response of the query will be:
 
-   ```json
-   {
+```json
+{
   "Nick": {
     "Sophie": {
       "Jonas": {}
     }
   }
 }
-   ```
+```
 
 Sophie is the supervisor of the Nick and Jonas is supervisor of the supervisor of the Nick
 
@@ -108,34 +121,41 @@ Sophie is the supervisor of the Nick and Jonas is supervisor of the supervisor o
 Sign up to the system
 
 ```bash
-      curl --request POST -sL \
-           --url 'http://localhost:3000/signup'\
-           --header "Content-Type: application/json" \
-           --data '{"username":"jane","password":"doe"}'
+curl --request POST -sL \
+    --url 'http://localhost:3000/signup'\
+    --header "Content-Type: application/json" \
+    --data '{"username":"jane","password":"doe"}'
   ```
 
 login to the system
 
 ```bash
-      curl --request POST -sL \
-           --url 'http://localhost:3000/login'\
-           --header "Content-Type: application/json" \
-           --data '{"username":"jane","password":"doe"}'
-  ```
+curl --request POST -sL \
+    --url 'http://localhost:3000/login'\
+    --header "Content-Type: application/json" \
+    --data '{"username":"jane","password":"doe"}'
+```
 
 The response will be the access token
 
 ```json
-       {
+{
   "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJodHRwOi8vMC4wLjAuMDo4MDgwL2hpZXJhcmNoeSIsImlzcyI6Imh0dHA6Ly8wLjAuMC4wOjgwODAvIiwiZXhwIjoxNjUwMTU3NjIxLCJ1c2VybmFtZSI6ImpvaG4ifQ.LSJUte7oy9Kv7qkozI3APBzPxHVZ56GID-n0lRIKvdY"
 }
 ```
 
-Also, you can use following [Postman JSON collection file](/postman_collection.json) and test the application from
-Postman
+## How to test locally
+For testing the project locally you can run docker compose with `docker-compose-test.yml` file. It will run the tests
+against a test database.
+```bash
+docker-compose --file docker-compose-test.yml up 
+```
+After finishing the tests you can clean test data nd  shut the containers down with following command:
 
-To deploy the test environment and test the application:
+```bash
+docker-compose --file docker-compose-test.yml down -v
+```
 
-   ```bash
-   docker-compose --file docker-compose-test.yml up 
-   ```
+## Continues Integration
+For continues integration, the CI workflow prepares the database, run the gradle build with tests, and generates report
+to Codacy about the quality of code.

build.gradle.kts

@@ -2,7 +2,7 @@ val ktor_version: String by project
 val kotlin_version: String by project
 val logback_version: String by project
 val exposed_version: String by project
-val postgresql_version: String by project
+val database_driver_version: String by project
 val gson_version: String by project
 val jbcrypt_version: String by project
 val hikaricp_version: String by project
@@ -46,7 +46,8 @@ dependencies {
     implementation("org.jetbrains.exposed:exposed-core:$exposed_version")
     implementation("org.jetbrains.exposed:exposed-dao:$exposed_version")
     implementation("org.jetbrains.exposed:exposed-jdbc:$exposed_version")
-    implementation("org.postgresql:postgresql:$postgresql_version")
+    // add database driver below, default is postgres
+    implementation("org.postgresql:postgresql:$database_driver_version")
     implementation("com.google.code.gson:gson:$gson_version")
     implementation("io.ktor:ktor-server-auth:$ktor_version")
     implementation("io.ktor:ktor-server-status-pages:$ktor_version")

gradle.properties

@@ -1,9 +1,10 @@
-ktor_version=2.0.0
+ktor_version=2.2.4
 kotlin_version=1.6.20
 logback_version=1.2.11
 kotlin.code.style=official
 exposed_version=0.37.3
-postgresql_version=42.3.3
+# Postgresql driver version, it can be any db driver. Also change the equivalent dependency
+database_driver_version=42.5.1
 gson_version=2.9.0
 jbcrypt_version=0.4
 hikaricp_version=5.0.1

src/main/kotlin/com/personia/routes/HierarchyRoutes.kt

@@ -10,6 +10,7 @@ import io.ktor.server.response.*
 import io.ktor.server.routing.*
 
 fun Route.hierarchyRouting(nodeService: NodeService) {
+    val applicationJson = ContentType("application", "json")
     val gson = Gson()
 
     route("hierarchy") {
@@ -38,19 +39,13 @@ fun Route.hierarchyRouting(nodeService: NodeService) {
 
             val response = nodeService.retrieveSupervisors(name, level)
             val json: String = gson.toJson(response)
-            call.respondText(
-                text = json,
-                contentType = ContentType("application", "json")
-            )
+            call.respondText(text = json,contentType = applicationJson)
         }
         post {
             val hierarchy = call.receive<Map<String, String>>()
             val response = nodeService.createHierarchy(hierarchy)
             val json = gson.toJson(response)
-            call.respondText(
-                text = json,
-                contentType = ContentType("application", "json")
-            )
+            call.respondText(text = json,contentType = applicationJson)
         }
     }
 }