feat(rule): Rules as a microservice (#39)

Co-authored-by: LQ63 <lkhermann@web.de>
Co-authored-by: TeamCity <teamcity@service.local>
Reviewed-on: #39

modules/rule/src/main/docker/Dockerfile.jvm

@@ -0,0 +1,100 @@
+####
+# This Dockerfile is used in order to build a container that runs the Quarkus application in JVM mode
+#
+# Before building the container image run:
+#
+# ./gradlew build
+#
+# Then, build the image with:
+#
+# docker build -f src/main/docker/Dockerfile.jvm -t quarkus/backcore-jvm .
+#
+# Then run the container using:
+#
+# docker run -i --rm -p 8080:8080 quarkus/backcore-jvm
+#
+# If you want to include the debug port into your docker image
+# you will have to expose the debug port (default 5005 being the default) like this :  EXPOSE 8080 5005.
+# Additionally you will have to set -e JAVA_DEBUG=true and -e JAVA_DEBUG_PORT=*:5005
+# when running the container
+#
+# Then run the container using :
+#
+# docker run -i --rm -p 8080:8080 quarkus/backcore-jvm
+#
+# This image uses the `run-java.sh` script to run the application.
+# This scripts computes the command line to execute your Java application, and
+# includes memory/GC tuning.
+# You can configure the behavior using the following environment properties:
+# - JAVA_OPTS: JVM options passed to the `java` command (example: "-verbose:class") - Be aware that this will override
+# the default JVM options, use `JAVA_OPTS_APPEND` to append options
+# - JAVA_OPTS_APPEND: User specified Java options to be appended to generated options
+#   in JAVA_OPTS (example: "-Dsome.property=foo")
+# - JAVA_MAX_MEM_RATIO: Is used when no `-Xmx` option is given in JAVA_OPTS. This is
+#   used to calculate a default maximal heap memory based on a containers restriction.
+#   If used in a container without any memory constraints for the container then this
+#   option has no effect. If there is a memory constraint then `-Xmx` is set to a ratio
+#   of the container available memory as set here. The default is `50` which means 50%
+#   of the available memory is used as an upper boundary. You can skip this mechanism by
+#   setting this value to `0` in which case no `-Xmx` option is added.
+# - JAVA_INITIAL_MEM_RATIO: Is used when no `-Xms` option is given in JAVA_OPTS. This
+#   is used to calculate a default initial heap memory based on the maximum heap memory.
+#   If used in a container without any memory constraints for the container then this
+#   option has no effect. If there is a memory constraint then `-Xms` is set to a ratio
+#   of the `-Xmx` memory as set here. The default is `25` which means 25% of the `-Xmx`
+#   is used as the initial heap size. You can skip this mechanism by setting this value
+#   to `0` in which case no `-Xms` option is added (example: "25")
+# - JAVA_MAX_INITIAL_MEM: Is used when no `-Xms` option is given in JAVA_OPTS.
+#   This is used to calculate the maximum value of the initial heap memory. If used in
+#   a container without any memory constraints for the container then this option has
+#   no effect. If there is a memory constraint then `-Xms` is limited to the value set
+#   here. The default is 4096MB which means the calculated value of `-Xms` never will
+#   be greater than 4096MB. The value of this variable is expressed in MB (example: "4096")
+# - JAVA_DIAGNOSTICS: Set this to get some diagnostics information to standard output
+#   when things are happening. This option, if set to true, will set
+#  `-XX:+UnlockDiagnosticVMOptions`. Disabled by default (example: "true").
+# - JAVA_DEBUG: If set remote debugging will be switched on. Disabled by default (example:
+#    true").
+# - JAVA_DEBUG_PORT: Port used for remote debugging. Defaults to 5005 (example: "8787").
+# - CONTAINER_CORE_LIMIT: A calculated core limit as described in
+#   https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt. (example: "2")
+# - CONTAINER_MAX_MEMORY: Memory limit given to the container (example: "1024").
+# - GC_MIN_HEAP_FREE_RATIO: Minimum percentage of heap free after GC to avoid expansion.
+#   (example: "20")
+# - GC_MAX_HEAP_FREE_RATIO: Maximum percentage of heap free after GC to avoid shrinking.
+#   (example: "40")
+# - GC_TIME_RATIO: Specifies the ratio of the time spent outside the garbage collection.
+#   (example: "4")
+# - GC_ADAPTIVE_SIZE_POLICY_WEIGHT: The weighting given to the current GC time versus
+#   previous GC times. (example: "90")
+# - GC_METASPACE_SIZE: The initial metaspace size. (example: "20")
+# - GC_MAX_METASPACE_SIZE: The maximum metaspace size. (example: "100")
+# - GC_CONTAINER_OPTIONS: Specify Java GC to use. The value of this variable should
+#   contain the necessary JRE command-line options to specify the required GC, which
+#   will override the default of `-XX:+UseParallelGC` (example: -XX:+UseG1GC).
+# - HTTPS_PROXY: The location of the https proxy. (example: "myuser@127.0.0.1:8080")
+# - HTTP_PROXY: The location of the http proxy. (example: "myuser@127.0.0.1:8080")
+# - NO_PROXY: A comma separated lists of hosts, IP addresses or domains that can be
+#   accessed directly. (example: "foo.example.com,bar.example.com")
+#
+# You can find more information about the UBI base runtime images and their configuration here:
+# https://rh-openjdk.github.io/redhat-openjdk-containers/
+###
+FROM registry.access.redhat.com/ubi9/openjdk-21-runtime:1.24
+
+ENV LANGUAGE='en_US:en'
+
+
+# We make four distinct layers so if there are application changes the library layers can be re-used
+COPY --chown=185 build/quarkus-app/lib/ /deployments/lib/
+COPY --chown=185 build/quarkus-app/*.jar /deployments/
+COPY --chown=185 build/quarkus-app/app/ /deployments/app/
+COPY --chown=185 build/quarkus-app/quarkus/ /deployments/quarkus/
+
+EXPOSE 8080
+USER 185
+ENV JAVA_OPTS_APPEND="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager"
+ENV JAVA_APP_JAR="/deployments/quarkus-run.jar"
+
+ENTRYPOINT [ "/opt/jboss/container/java/run/run-java.sh" ]
+

modules/rule/src/main/docker/Dockerfile.legacy-jar

@@ -0,0 +1,96 @@
+####
+# This Dockerfile is used in order to build a container that runs the Quarkus application in JVM mode
+#
+# Before building the container image run:
+#
+# ./gradlew build -Dquarkus.package.jar.type=legacy-jar
+#
+# Then, build the image with:
+#
+# docker build -f src/main/docker/Dockerfile.legacy-jar -t quarkus/backcore-legacy-jar .
+#
+# Then run the container using:
+#
+# docker run -i --rm -p 8080:8080 quarkus/backcore-legacy-jar
+#
+# If you want to include the debug port into your docker image
+# you will have to expose the debug port (default 5005 being the default) like this :  EXPOSE 8080 5005.
+# Additionally you will have to set -e JAVA_DEBUG=true and -e JAVA_DEBUG_PORT=*:5005
+# when running the container
+#
+# Then run the container using :
+#
+# docker run -i --rm -p 8080:8080 quarkus/backcore-legacy-jar
+#
+# This image uses the `run-java.sh` script to run the application.
+# This scripts computes the command line to execute your Java application, and
+# includes memory/GC tuning.
+# You can configure the behavior using the following environment properties:
+# - JAVA_OPTS: JVM options passed to the `java` command (example: "-verbose:class") - Be aware that this will override
+# the default JVM options, use `JAVA_OPTS_APPEND` to append options
+# - JAVA_OPTS_APPEND: User specified Java options to be appended to generated options
+#   in JAVA_OPTS (example: "-Dsome.property=foo")
+# - JAVA_MAX_MEM_RATIO: Is used when no `-Xmx` option is given in JAVA_OPTS. This is
+#   used to calculate a default maximal heap memory based on a containers restriction.
+#   If used in a container without any memory constraints for the container then this
+#   option has no effect. If there is a memory constraint then `-Xmx` is set to a ratio
+#   of the container available memory as set here. The default is `50` which means 50%
+#   of the available memory is used as an upper boundary. You can skip this mechanism by
+#   setting this value to `0` in which case no `-Xmx` option is added.
+# - JAVA_INITIAL_MEM_RATIO: Is used when no `-Xms` option is given in JAVA_OPTS. This
+#   is used to calculate a default initial heap memory based on the maximum heap memory.
+#   If used in a container without any memory constraints for the container then this
+#   option has no effect. If there is a memory constraint then `-Xms` is set to a ratio
+#   of the `-Xmx` memory as set here. The default is `25` which means 25% of the `-Xmx`
+#   is used as the initial heap size. You can skip this mechanism by setting this value
+#   to `0` in which case no `-Xms` option is added (example: "25")
+# - JAVA_MAX_INITIAL_MEM: Is used when no `-Xms` option is given in JAVA_OPTS.
+#   This is used to calculate the maximum value of the initial heap memory. If used in
+#   a container without any memory constraints for the container then this option has
+#   no effect. If there is a memory constraint then `-Xms` is limited to the value set
+#   here. The default is 4096MB which means the calculated value of `-Xms` never will
+#   be greater than 4096MB. The value of this variable is expressed in MB (example: "4096")
+# - JAVA_DIAGNOSTICS: Set this to get some diagnostics information to standard output
+#   when things are happening. This option, if set to true, will set
+#  `-XX:+UnlockDiagnosticVMOptions`. Disabled by default (example: "true").
+# - JAVA_DEBUG: If set remote debugging will be switched on. Disabled by default (example:
+#    true").
+# - JAVA_DEBUG_PORT: Port used for remote debugging. Defaults to 5005 (example: "8787").
+# - CONTAINER_CORE_LIMIT: A calculated core limit as described in
+#   https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt. (example: "2")
+# - CONTAINER_MAX_MEMORY: Memory limit given to the container (example: "1024").
+# - GC_MIN_HEAP_FREE_RATIO: Minimum percentage of heap free after GC to avoid expansion.
+#   (example: "20")
+# - GC_MAX_HEAP_FREE_RATIO: Maximum percentage of heap free after GC to avoid shrinking.
+#   (example: "40")
+# - GC_TIME_RATIO: Specifies the ratio of the time spent outside the garbage collection.
+#   (example: "4")
+# - GC_ADAPTIVE_SIZE_POLICY_WEIGHT: The weighting given to the current GC time versus
+#   previous GC times. (example: "90")
+# - GC_METASPACE_SIZE: The initial metaspace size. (example: "20")
+# - GC_MAX_METASPACE_SIZE: The maximum metaspace size. (example: "100")
+# - GC_CONTAINER_OPTIONS: Specify Java GC to use. The value of this variable should
+#   contain the necessary JRE command-line options to specify the required GC, which
+#   will override the default of `-XX:+UseParallelGC` (example: -XX:+UseG1GC).
+# - HTTPS_PROXY: The location of the https proxy. (example: "myuser@127.0.0.1:8080")
+# - HTTP_PROXY: The location of the http proxy. (example: "myuser@127.0.0.1:8080")
+# - NO_PROXY: A comma separated lists of hosts, IP addresses or domains that can be
+#   accessed directly. (example: "foo.example.com,bar.example.com")
+#
+# You can find more information about the UBI base runtime images and their configuration here:
+# https://rh-openjdk.github.io/redhat-openjdk-containers/
+###
+FROM registry.access.redhat.com/ubi9/openjdk-21-runtime:1.24
+
+ENV LANGUAGE='en_US:en'
+
+
+COPY build/lib/* /deployments/lib/
+COPY build/*-runner.jar /deployments/quarkus-run.jar
+
+EXPOSE 8080
+USER 185
+ENV JAVA_OPTS_APPEND="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager"
+ENV JAVA_APP_JAR="/deployments/quarkus-run.jar"
+
+ENTRYPOINT [ "/opt/jboss/container/java/run/run-java.sh" ]

modules/rule/src/main/docker/Dockerfile.native

@@ -0,0 +1,29 @@
+####
+# This Dockerfile is used in order to build a container that runs the Quarkus application in native (no JVM) mode.
+#
+# Before building the container image run:
+#
+# ./gradlew build -Dquarkus.native.enabled=true
+#
+# Then, build the image with:
+#
+# docker build -f src/main/docker/Dockerfile.native -t quarkus/backcore .
+#
+# Then run the container using:
+#
+# docker run -i --rm -p 8080:8080 quarkus/backcore
+#
+# The ` registry.access.redhat.com/ubi9/ubi-minimal:9.7` base image is based on UBI 9.
+# To use UBI 8, switch to `quay.io/ubi8/ubi-minimal:8.10`.
+###
+FROM registry.access.redhat.com/ubi9/ubi-minimal:9.7
+WORKDIR /work/
+RUN chown 1001 /work \
+    && chmod "g+rwX" /work \
+    && chown 1001:root /work
+COPY --chown=1001:root --chmod=0755 build/*-runner /work/application
+
+EXPOSE 8080
+USER 1001
+
+ENTRYPOINT ["./application", "-Dquarkus.http.host=0.0.0.0"]

modules/rule/src/main/docker/Dockerfile.native-micro

@@ -0,0 +1,32 @@
+####
+# This Dockerfile is used in order to build a container that runs the Quarkus application in native (no JVM) mode.
+# It uses a micro base image, tuned for Quarkus native executables.
+# It reduces the size of the resulting container image.
+# Check https://quarkus.io/guides/quarkus-runtime-base-image for further information about this image.
+#
+# Before building the container image run:
+#
+# ./gradlew build -Dquarkus.native.enabled=true
+#
+# Then, build the image with:
+#
+# docker build -f src/main/docker/Dockerfile.native-micro -t quarkus/backcore .
+#
+# Then run the container using:
+#
+# docker run -i --rm -p 8080:8080 quarkus/backcore
+#
+# The `quay.io/quarkus/ubi9-quarkus-micro-image:2.0` base image is based on UBI 9.
+# To use UBI 8, switch to `quay.io/quarkus/quarkus-micro-image:2.0`.
+###
+FROM quay.io/quarkus/ubi9-quarkus-micro-image:2.0
+WORKDIR /work/
+RUN chown 1001 /work \
+    && chmod "g+rwX" /work \
+    && chown 1001:root /work
+COPY --chown=1001:root --chmod=0755 build/*-runner /work/application
+
+EXPOSE 8080
+USER 1001
+
+ENTRYPOINT ["./application", "-Dquarkus.http.host=0.0.0.0"]

modules/rule/src/main/resources/application.yml

@@ -0,0 +1,5 @@
+quarkus:
+  http:
+    port: 8082
+  application:
+    name: rule-service

modules/rule/src/main/scala/de/nowchess/rules/RuleSet.scala

@@ -1,41 +0,0 @@
-package de.nowchess.rules
-
-import de.nowchess.api.game.GameContext
-import de.nowchess.api.board.Square
-import de.nowchess.api.move.Move
-
-/** Extension point for chess rule variants (standard, Chess960, etc.). All rule queries are stateless: given a
-  * GameContext, return the answer.
-  */
-trait RuleSet:
-  /** All pseudo-legal moves for the piece on `square` (ignores check). */
-  def candidateMoves(context: GameContext)(square: Square): List[Move]
-
-  /** Legal moves for `square`: candidates that don't leave own king in check. */
-  def legalMoves(context: GameContext)(square: Square): List[Move]
-
-  /** All legal moves for the side to move. */
-  def allLegalMoves(context: GameContext): List[Move]
-
-  /** True if the side to move's king is in check. */
-  def isCheck(context: GameContext): Boolean
-
-  /** True if the side to move is in check and has no legal moves. */
-  def isCheckmate(context: GameContext): Boolean
-
-  /** True if the side to move is not in check and has no legal moves. */
-  def isStalemate(context: GameContext): Boolean
-
-  /** True if neither side has enough material to checkmate. */
-  def isInsufficientMaterial(context: GameContext): Boolean
-
-  /** True if halfMoveClock >= 100 (50-move rule). */
-  def isFiftyMoveRule(context: GameContext): Boolean
-
-  /** True if the same position has occurred 3 times (including current position). */
-  def isThreefoldRepetition(context: GameContext): Boolean
-
-  /** Apply a legal move to produce the next game context. Handles all special move types: castling, en passant,
-    * promotion. Updates castling rights, en passant square, half-move clock, turn, and move history.
-    */
-  def applyMove(context: GameContext)(move: Move): GameContext

modules/rule/src/main/scala/de/nowchess/rules/config/JacksonConfig.scala

@@ -0,0 +1,29 @@
+package de.nowchess.rules.config
+
+import com.fasterxml.jackson.core.Version
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.databind.module.SimpleModule
+import com.fasterxml.jackson.module.scala.DefaultScalaModule
+import de.nowchess.api.board.Square
+import de.nowchess.api.move.MoveType
+import de.nowchess.rules.json.*
+import io.quarkus.jackson.ObjectMapperCustomizer
+import jakarta.inject.Singleton
+
+@Singleton
+class JacksonConfig extends ObjectMapperCustomizer:
+  def customize(mapper: ObjectMapper): Unit =
+    mapper.registerModule(new DefaultScalaModule() {
+      override def version(): Version =
+        // scalafix:off DisableSyntax.null
+        new Version(2, 21, 1, null, "com.fasterxml.jackson.module", "jackson-module-scala")
+        // scalafix:on DisableSyntax.null
+    })
+    val mod = new SimpleModule()
+    mod.addKeySerializer(classOf[Square], new SquareKeySerializer())
+    mod.addKeyDeserializer(classOf[Square], new SquareKeyDeserializer())
+    mod.addSerializer(classOf[Square], new SquareSerializer())
+    mod.addDeserializer(classOf[Square], new SquareDeserializer())
+    mod.addSerializer(classOf[MoveType], new MoveTypeSerializer())
+    mod.addDeserializer(classOf[MoveType], new MoveTypeDeserializer())
+    mapper.registerModule(mod)

modules/rule/src/main/scala/de/nowchess/rules/config/NativeReflectionConfig.scala

@@ -0,0 +1,28 @@
+package de.nowchess.rules.config
+
+import de.nowchess.api.board.{CastlingRights, Color, File, Piece, PieceType, Rank, Square}
+import de.nowchess.api.game.{DrawReason, GameContext, GameResult}
+import de.nowchess.api.move.{Move, MoveType, PromotionPiece}
+import de.nowchess.rules.dto.{ContextMoveRequest, ContextSquareRequest}
+import io.quarkus.runtime.annotations.RegisterForReflection
+
+@RegisterForReflection(
+  targets = Array(
+    classOf[ContextSquareRequest],
+    classOf[ContextMoveRequest],
+    classOf[GameContext],
+    classOf[GameResult],
+    classOf[DrawReason],
+    classOf[Color],
+    classOf[Piece],
+    classOf[PieceType],
+    classOf[CastlingRights],
+    classOf[Square],
+    classOf[File],
+    classOf[Rank],
+    classOf[Move],
+    classOf[MoveType],
+    classOf[PromotionPiece],
+  ),
+)
+class NativeReflectionConfig

modules/rule/src/main/scala/de/nowchess/rules/dto/Dtos.scala

@@ -0,0 +1,8 @@
+package de.nowchess.rules.dto
+
+import de.nowchess.api.game.GameContext
+import de.nowchess.api.move.Move
+
+case class ContextSquareRequest(context: GameContext, square: String)
+
+case class ContextMoveRequest(context: GameContext, move: Move)

modules/rule/src/main/scala/de/nowchess/rules/json/MoveTypeDeserializer.scala

@@ -0,0 +1,19 @@
+package de.nowchess.rules.json
+
+import com.fasterxml.jackson.core.{JsonParseException, JsonParser}
+import com.fasterxml.jackson.databind.node.ObjectNode
+import com.fasterxml.jackson.databind.{DeserializationContext, JsonDeserializer}
+import de.nowchess.api.move.{MoveType, PromotionPiece}
+
+class MoveTypeDeserializer extends JsonDeserializer[MoveType]:
+  // scalafix:off DisableSyntax.throw
+  override def deserialize(p: JsonParser, ctx: DeserializationContext): MoveType =
+    val node = p.getCodec.readTree[ObjectNode](p)
+    node.get("type").asText() match
+      case "normal"          => MoveType.Normal(node.get("isCapture").asBoolean(false))
+      case "castleKingside"  => MoveType.CastleKingside
+      case "castleQueenside" => MoveType.CastleQueenside
+      case "enPassant"       => MoveType.EnPassant
+      case "promotion"       => MoveType.Promotion(PromotionPiece.valueOf(node.get("piece").asText()))
+      case t                 => throw new JsonParseException(p, s"Unknown move type: $t")
+  // scalafix:on DisableSyntax.throw

modules/rule/src/main/scala/de/nowchess/rules/json/MoveTypeSerializer.scala

@@ -0,0 +1,23 @@
+package de.nowchess.rules.json
+
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.databind.{JsonSerializer, SerializerProvider}
+import de.nowchess.api.move.MoveType
+
+class MoveTypeSerializer extends JsonSerializer[MoveType]:
+  override def serialize(value: MoveType, gen: JsonGenerator, provider: SerializerProvider): Unit =
+    gen.writeStartObject()
+    value match
+      case MoveType.Normal(isCapture) =>
+        gen.writeStringField("type", "normal")
+        gen.writeBooleanField("isCapture", isCapture)
+      case MoveType.CastleKingside =>
+        gen.writeStringField("type", "castleKingside")
+      case MoveType.CastleQueenside =>
+        gen.writeStringField("type", "castleQueenside")
+      case MoveType.EnPassant =>
+        gen.writeStringField("type", "enPassant")
+      case MoveType.Promotion(piece) =>
+        gen.writeStringField("type", "promotion")
+        gen.writeStringField("piece", piece.toString)
+    gen.writeEndObject()

modules/rule/src/main/scala/de/nowchess/rules/json/SquareDeserializer.scala

@@ -0,0 +1,9 @@
+package de.nowchess.rules.json
+
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.databind.{DeserializationContext, JsonDeserializer}
+import de.nowchess.api.board.Square
+
+class SquareDeserializer extends JsonDeserializer[Square]:
+  override def deserialize(p: JsonParser, ctx: DeserializationContext): Square =
+    Square.fromAlgebraic(p.getText).orNull

modules/rule/src/main/scala/de/nowchess/rules/json/SquareKeyDeserializer.scala

@@ -0,0 +1,8 @@
+package de.nowchess.rules.json
+
+import com.fasterxml.jackson.databind.{DeserializationContext, KeyDeserializer}
+import de.nowchess.api.board.Square
+
+class SquareKeyDeserializer extends KeyDeserializer:
+  override def deserializeKey(key: String, ctx: DeserializationContext): AnyRef =
+    Square.fromAlgebraic(key).orNull

modules/rule/src/main/scala/de/nowchess/rules/json/SquareKeySerializer.scala

@@ -0,0 +1,9 @@
+package de.nowchess.rules.json
+
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.databind.{JsonSerializer, SerializerProvider}
+import de.nowchess.api.board.Square
+
+class SquareKeySerializer extends JsonSerializer[Square]:
+  override def serialize(value: Square, gen: JsonGenerator, provider: SerializerProvider): Unit =
+    gen.writeFieldName(value.toString)

modules/rule/src/main/scala/de/nowchess/rules/json/SquareSerializer.scala

@@ -0,0 +1,9 @@
+package de.nowchess.rules.json
+
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.databind.{JsonSerializer, SerializerProvider}
+import de.nowchess.api.board.Square
+
+class SquareSerializer extends JsonSerializer[Square]:
+  override def serialize(value: Square, gen: JsonGenerator, provider: SerializerProvider): Unit =
+    gen.writeString(value.toString)

modules/rule/src/main/scala/de/nowchess/rules/resource/RuleSetResource.scala

@@ -0,0 +1,90 @@
+package de.nowchess.rules.resource
+
+import de.nowchess.api.board.Square
+import de.nowchess.api.game.GameContext
+import de.nowchess.api.move.Move
+import de.nowchess.rules.dto.*
+import de.nowchess.rules.sets.DefaultRules
+import jakarta.enterprise.context.ApplicationScoped
+import jakarta.ws.rs.*
+import jakarta.ws.rs.core.MediaType
+
+@Path("/api/rules")
+@ApplicationScoped
+class RuleSetResource:
+  private val rules = DefaultRules
+
+  // scalafix:off DisableSyntax.throw
+  private def parseSquare(s: String): Square =
+    Square.fromAlgebraic(s).getOrElse(throw new BadRequestException(s"Invalid square: $s"))
+  // scalafix:on DisableSyntax.throw
+
+  @POST
+  @Path("/candidate-moves")
+  @Consumes(Array(MediaType.APPLICATION_JSON))
+  @Produces(Array(MediaType.APPLICATION_JSON))
+  def candidateMoves(req: ContextSquareRequest): List[Move] =
+    rules.candidateMoves(req.context)(parseSquare(req.square))
+
+  @POST
+  @Path("/legal-moves")
+  @Consumes(Array(MediaType.APPLICATION_JSON))
+  @Produces(Array(MediaType.APPLICATION_JSON))
+  def legalMoves(req: ContextSquareRequest): List[Move] =
+    rules.legalMoves(req.context)(parseSquare(req.square))
+
+  @POST
+  @Path("/all-legal-moves")
+  @Consumes(Array(MediaType.APPLICATION_JSON))
+  @Produces(Array(MediaType.APPLICATION_JSON))
+  def allLegalMoves(ctx: GameContext): List[Move] =
+    rules.allLegalMoves(ctx)
+
+  @POST
+  @Path("/is-check")
+  @Consumes(Array(MediaType.APPLICATION_JSON))
+  @Produces(Array(MediaType.APPLICATION_JSON))
+  def isCheck(ctx: GameContext): Boolean =
+    rules.isCheck(ctx)
+
+  @POST
+  @Path("/is-checkmate")
+  @Consumes(Array(MediaType.APPLICATION_JSON))
+  @Produces(Array(MediaType.APPLICATION_JSON))
+  def isCheckmate(ctx: GameContext): Boolean =
+    rules.isCheckmate(ctx)
+
+  @POST
+  @Path("/is-stalemate")
+  @Consumes(Array(MediaType.APPLICATION_JSON))
+  @Produces(Array(MediaType.APPLICATION_JSON))
+  def isStalemate(ctx: GameContext): Boolean =
+    rules.isStalemate(ctx)
+
+  @POST
+  @Path("/is-insufficient-material")
+  @Consumes(Array(MediaType.APPLICATION_JSON))
+  @Produces(Array(MediaType.APPLICATION_JSON))
+  def isInsufficientMaterial(ctx: GameContext): Boolean =
+    rules.isInsufficientMaterial(ctx)
+
+  @POST
+  @Path("/is-fifty-move-rule")
+  @Consumes(Array(MediaType.APPLICATION_JSON))
+  @Produces(Array(MediaType.APPLICATION_JSON))
+  def isFiftyMoveRule(ctx: GameContext): Boolean =
+    rules.isFiftyMoveRule(ctx)
+
+  @POST
+  @Path("/is-threefold-repetition")
+  @Consumes(Array(MediaType.APPLICATION_JSON))
+  @Produces(Array(MediaType.APPLICATION_JSON))
+  def isThreefoldRepetition(ctx: GameContext): Boolean =
+    rules.isThreefoldRepetition(ctx)
+
+  @POST
+  @Path("/apply-move")
+  @Consumes(Array(MediaType.APPLICATION_JSON))
+  @Produces(Array(MediaType.APPLICATION_JSON))
+  def applyMove(req: ContextMoveRequest): GameContext =
+    rules.applyMove(req.context)(req.move)

modules/rule/src/main/scala/de/nowchess/rules/sets/DefaultRules.scala

@@ -3,7 +3,7 @@ package de.nowchess.rules.sets
 import de.nowchess.api.board.*
 import de.nowchess.api.game.GameContext
 import de.nowchess.api.move.{Move, MoveType, PromotionPiece}
-import de.nowchess.rules.RuleSet
+import de.nowchess.api.rules.RuleSet
 
 import scala.annotation.tailrec