The goal is to implement a GraphQL service with example query and mutation.

To do:

• add an sbt module for that service
• implement an example query (e.g. returning "Hello world!")
• implement an example mutation (e.g. changing current username and returning previous one)
• add Akka HTTP endpoint
• add GraphiQL interface
• add logging
• config file for server port etc.
• test implemented service
• create a docker container with the service

As multiple pull requests are created each time Scala Steward is run they can be merged automatically. A tool like Mergify can be used for this purpose.

The tool should include:

• merging automatically when checks pass
• automatically updating pull requests to newest version of master branch
• labeling pull requests dedicated to dependencies updates

Wiki pages are quite outdated, update them according to newest changes.

Describe:

• common module
  • config module
  • logging module
• scripts and their arguments

Extract the config trait from basic GraphQL service to a separate module that can be used across other modules.

To do:

• extract trait to a separate module
• test if config for basic GraphQL service works correctly with it

Currently scripts have common parts and are not really flexible due to hardcoded service names and profiles. The goal is to extract not obvious parts to functions and generally improve the maintainability of the scripts.

To do:

• move project names to a variable
• move profiles to a variable There are only a few profiles so it is not important. Also it is problematic to implement. Skipped.
• extract common parts
• create functions that are easy to read

Use sbt plugins to create Docker image of the service and test if it works correctly. It will probably be also useful to include env variables in config (for port mapping) and create a Docker compose file.

Add basic UI for the page using Angular.

To do:

• input field for uri to cut
• displaying cutting result with "copy to clipboard" icon
• a special page for 404 error in link-store

Create a logging trait that will be able to dynamically change logging level. Module should use Scribe. Dynamic logging level should be handled via REST endpoint at localhost:1065/logging. REST is used because it's simpler than GraphQL for this task and doesn't require Sangria. The trait should be reusable across other modules by including it to App trait (so this: App => self type is required).

Example request that changes logging level to debug:
POST @ localhost:1065/logging

{
    "minimumLevel": "DEBUG"
}

It should set logging level to debug and return 204 No Content.

Requirements:

• Scribe as logging library
• Akka HTTP for server and endpoint
• Circe for Json decoding

To do:

• implement logging trait as described above
• attach it to existing services that use logging
• test implementation

Cutting a link:

• receive link created message from Kafka
• save created link to Elasticsearch
• test implementation

Link retrieval:

• receive retrieve link request
• retrieve link from Elasticsearch
• send link retrieved message to Kafka
• send a redirection with retrieved link
• test implementation

The link retrieval should be done via basic HTTP calls instead of GraphQL. In the future this service can be extended with GraphQL queries support.

Build a cut-link service basing on basic-graphql module.

To do:

• receive cut link mutation
• send cut link request message to Kafka
• send cut link response
• set up Kafka
• test implemented service
• update run.sh and stop.sh to new docker-compose files

Scaladoc for public API in:

• config
• logging

Add container tests for classes that are using Kafka and Elasticsearch directly.

To do:

• KafkaConnector
• ElasticConnector
• cut link flow (from request to ES document)
• retrieve link flow (from request to link retrieved Kafka event)

Currently the logging module allows only to set the global logging level which is not convenient because eg. Kafka has many trace level logs. The idea is to split the logging settings into a separate level for main project package and other packages. Example: cut.link.* has logging level TRACE and other packages have logging level WARN. Also for further potential extensions of this module the server should have GraphQL interface with GraphiQL endpoint.

To do:

• change REST to GraphQL
• add default level setting for main package and other packages as overridable method
• add an option to change both levels via GraphQL mutation
• test implementation

Using kafkalytic is not possible for Kafka. The plugin says that the connection is successful but loading topics etc. does not work. The development process is easier with this kind of third party tools.

https://github.com/marketplace/actions/scala-steward-github-action - use manual triggering for triggering dependency updates from time to time. It might be useful to use sbt-updates plugin to check if it is necessary to run the workflow.

Add workflows for:

• Scala style using ScalaFMT
• build
• tests

Preserve the order of checks from the list above if possible.

Test each workflow by providing invalid and then valid code in commits:

• Scala style using ScalaFMT
• build
• tests