✨ feat: add interceptor for paid commands, which should withdraw resources to be handled (#22)

+ resolve `RecruitCreature` as paid command

Justification:
This solution is a tradeoff: we couple slices on the interceptor level
(can be treated as adapter, like REST API) within the same UnitOfWork /
transaction, but we avoid custom orchestration logic with Saga pattern.

Author: MateuszNaKodach

generated-requests.http

@@ -28,7 +28,11 @@ Content-Type: application/json
 {
   "creatureId": "angel",
   "armyId": "army-1",
-  "quantity": 3
+  "quantity": 3,
+  "expectedCost": {
+    "gold": 9000,
+    "gems": 3
+  }
 }
 
 ### Dwelling read model

src/main/java/com/dddheroes/heroesofddd/creaturerecruitment/CreatureRecruitmentConfiguration.java

@@ -0,0 +1,26 @@
+package com.dddheroes.heroesofddd.creaturerecruitment;
+
+import com.dddheroes.heroesofddd.creaturerecruitment.write.recruitcreature.RecruitCreature;
+import com.dddheroes.heroesofddd.resourcespool.application.CommandCostResolver;
+import com.dddheroes.heroesofddd.shared.domain.valueobjects.Resources;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+class CreatureRecruitmentConfiguration {
+
+    @Bean
+    CommandCostResolver<RecruitCreature> recruitCreatureCostResolver() {
+        return new CommandCostResolver<>() {
+            @Override
+            public <T extends RecruitCreature> Resources resolve(T command) {
+                return command.expectedCost();
+            }
+
+            @Override
+            public Class<? extends RecruitCreature> supportedCommandType() {
+                return RecruitCreature.class;
+            }
+        };
+    }
+}

src/main/java/com/dddheroes/heroesofddd/creaturerecruitment/write/Dwelling.java

@@ -7,6 +7,7 @@
 import com.dddheroes.heroesofddd.creaturerecruitment.write.changeavailablecreatures.IncreaseAvailableCreatures;
 import com.dddheroes.heroesofddd.creaturerecruitment.write.changeavailablecreatures.OnlyBuiltDwellingCanHaveAvailableCreatures;
 import com.dddheroes.heroesofddd.creaturerecruitment.events.CreatureRecruited;
+import com.dddheroes.heroesofddd.creaturerecruitment.write.recruitcreature.RecruitCostCannotDifferThanExpectedCost;
 import com.dddheroes.heroesofddd.creaturerecruitment.write.recruitcreature.RecruitCreature;
 import com.dddheroes.heroesofddd.creaturerecruitment.write.recruitcreature.RecruitCreaturesNotExceedAvailableCreatures;
 import com.dddheroes.heroesofddd.shared.domain.valueobjects.Amount;
@@ -22,7 +23,7 @@
 import static org.axonframework.modelling.command.AggregateLifecycle.*;
 
 @Aggregate
-class Dwelling {
+public class Dwelling {
 
     @AggregateIdentifier
     private DwellingId dwellingId;
@@ -84,13 +85,19 @@ void decide(RecruitCreature command) {
                 command.quantity()
         ).verify();
 
+        var recruitCost = costPerTroop.multiply(command.quantity());
+        new RecruitCostCannotDifferThanExpectedCost(
+                recruitCost,
+                command.expectedCost()
+        ).verify();
+
         apply(
                 CreatureRecruited.event(
                         command.dwellingId(),
                         command.creatureId(),
                         command.toArmy(),
                         command.quantity(),
-                        costPerTroop.multiply(command.quantity())
+                        recruitCost
                 )
         );
     }

src/main/java/com/dddheroes/heroesofddd/creaturerecruitment/write/recruitcreature/RecruitCostCannotDifferThanExpectedCost.java

@@ -0,0 +1,20 @@
+package com.dddheroes.heroesofddd.creaturerecruitment.write.recruitcreature;
+
+import com.dddheroes.heroesofddd.shared.domain.DomainRule;
+import com.dddheroes.heroesofddd.shared.domain.valueobjects.Resources;
+
+public record RecruitCostCannotDifferThanExpectedCost(
+        Resources costPerTroop,
+        Resources expectedCostPerTroop
+) implements DomainRule {
+
+    @Override
+    public boolean isViolated() {
+        return !costPerTroop.isSame(expectedCostPerTroop);
+    }
+
+    @Override
+    public String message() {
+        return "Recruit cost cannot differ than expected cost";
+    }
+}

src/main/java/com/dddheroes/heroesofddd/creaturerecruitment/write/recruitcreature/RecruitCreature.java

@@ -5,20 +5,33 @@
 import com.dddheroes.heroesofddd.shared.domain.valueobjects.Amount;
 import com.dddheroes.heroesofddd.shared.domain.identifiers.ArmyId;
 import com.dddheroes.heroesofddd.shared.domain.identifiers.CreatureId;
+import com.dddheroes.heroesofddd.shared.domain.valueobjects.Resources;
 import org.axonframework.modelling.command.TargetAggregateIdentifier;
 
+import java.util.Map;
+
 public record RecruitCreature(
         @TargetAggregateIdentifier
         DwellingId dwellingId,
         CreatureId creatureId,
         ArmyId toArmy,
-        Amount quantity
+        Amount quantity,
+        Resources expectedCost
 ) implements DwellingCommand {
 
-    public static RecruitCreature command(String dwellingId, String creatureId, String toArmy, Integer quantity) {
-        return new RecruitCreature(DwellingId.of(dwellingId),
-                                   CreatureId.of(creatureId),
-                                   ArmyId.of(toArmy),
-                                   Amount.of(quantity));
+    public static RecruitCreature command(
+            String dwellingId,
+            String creatureId,
+            String toArmy,
+            Integer quantity,
+            Map<String, Integer> expectedCost
+    ) {
+        return new RecruitCreature(
+                DwellingId.of(dwellingId),
+                CreatureId.of(creatureId),
+                ArmyId.of(toArmy),
+                Amount.of(quantity),
+                Resources.fromRaw(expectedCost)
+        );
     }
 }

src/main/java/com/dddheroes/heroesofddd/creaturerecruitment/write/recruitcreature/RecruitCreatureRestApi.java

@@ -10,13 +10,14 @@
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 
 @RestController
 @RequestMapping("/games/{gameId}")
 class RecruitCreatureRestApi {
 
-    record Body(String creatureId, String armyId, Integer quantity) {
+    record Body(String creatureId, String armyId, Integer quantity, Map<String, Integer> expectedCost) {
 
     }
 
@@ -37,7 +38,8 @@ CompletableFuture<Void> putDwellingsCreatureRecruitments(
                 dwellingId,
                 requestBody.creatureId(),
                 requestBody.armyId(),
-                requestBody.quantity()
+                requestBody.quantity(),
+                requestBody.expectedCost()
         );
         return commandGateway.send(command, GameMetaData.with(gameId, playerId));
     }

src/main/java/com/dddheroes/heroesofddd/resourcespool/ResourcePoolConfiguration.java

@@ -0,0 +1,26 @@
+package com.dddheroes.heroesofddd.resourcespool;
+
+import com.dddheroes.heroesofddd.resourcespool.application.CommandCostResolver;
+import com.dddheroes.heroesofddd.resourcespool.application.ComposedCommandCostResolver;
+import com.dddheroes.heroesofddd.resourcespool.write.ResourcesPool;
+import com.dddheroes.heroesofddd.resourcespool.write.withdraw.PaidCommandInterceptor;
+import org.axonframework.modelling.command.Repository;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.Set;
+
+@Configuration
+class ResourcePoolConfiguration {
+
+    @Bean
+    PaidCommandInterceptor paidCommandInterceptor(
+            Set<CommandCostResolver<?>> commandCostResolvers,
+            Repository<ResourcesPool> resourcesPoolRepository
+    ) {
+        return new PaidCommandInterceptor(
+                new ComposedCommandCostResolver(commandCostResolvers),
+                resourcesPoolRepository
+        );
+    }
+}

src/main/java/com/dddheroes/heroesofddd/resourcespool/application/CommandCostResolver.java

@@ -0,0 +1,23 @@
+package com.dddheroes.heroesofddd.resourcespool.application;
+
+import com.dddheroes.heroesofddd.shared.domain.valueobjects.Resources;
+import com.dddheroes.heroesofddd.shared.slices.write.Command;
+
+public interface CommandCostResolver<C extends Command> {
+
+    default <T extends C> Resources cost(T command) {
+        if (isSupported(command)) {
+            return resolve(command);
+        } else {
+            return Resources.empty();
+        }
+    }
+
+    <T extends C> Resources resolve(T command);
+
+    default <T extends C> boolean isSupported(T command) {
+        return supportedCommandType().isAssignableFrom(command.getClass());
+    }
+
+    Class<? extends C> supportedCommandType();
+}

src/main/java/com/dddheroes/heroesofddd/resourcespool/application/ComposedCommandCostResolver.java

@@ -0,0 +1,39 @@
+package com.dddheroes.heroesofddd.resourcespool.application;
+
+import com.dddheroes.heroesofddd.shared.domain.valueobjects.Resources;
+import com.dddheroes.heroesofddd.shared.slices.write.Command;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class ComposedCommandCostResolver implements CommandCostResolver<Command> {
+
+    private final Map<Class<? extends Command>, CommandCostResolver<?>> resolvers;
+
+    public ComposedCommandCostResolver(Set<CommandCostResolver<?>> commandCostResolvers) {
+        this.resolvers = commandCostResolvers
+                .stream()
+                .collect(Collectors.toMap(
+                        CommandCostResolver::supportedCommandType,
+                        Function.identity()
+                ));
+    }
+
+
+    @Override
+    public <T extends Command> Resources resolve(T command) {
+        @SuppressWarnings("unchecked")
+        var resolver = (CommandCostResolver<T>) resolvers.get(command.getClass());
+        if (resolver == null) {
+            return Resources.empty();
+        }
+        return resolver.resolve(command);
+    }
+
+    @Override
+    public Class<? extends Command> supportedCommandType() {
+        return Command.class;
+    }
+}

src/main/java/com/dddheroes/heroesofddd/resourcespool/write/ResourcesPool.java

@@ -16,7 +16,7 @@
 import static org.axonframework.modelling.command.AggregateLifecycle.apply;
 
 @Aggregate
-class ResourcesPool {
+public class ResourcesPool {
 
     @AggregateIdentifier
     private ResourcesPoolId resourcesPoolId;
@@ -35,7 +35,7 @@ void evolve(ResourcesDeposited event) {
     }
 
     @CommandHandler
-    void decide(WithdrawResources command) {
+    public void decide(WithdrawResources command) {
         new CannotWithdrawMoreThanDepositedResources(
                 balance,
                 command.resources()