Vanilla API

Author: larousso

.sdkmanrc

@@ -1,3 +1,3 @@
 # Enable auto-env through the sdkman_auto_env config
 # Add key=value pairs of SDKs to use below
-java=17.0.7-tem
+java=open-21

build.gradle

@@ -22,23 +22,24 @@ subprojects {
         withSourcesJar()
         withJavadocJar()
         toolchain {
-            languageVersion = JavaLanguageVersion.of(17)
+            languageVersion = JavaLanguageVersion.of(21)
         }
     }
 
     ext {
         scalaVersion          = "2.13"
         alpakkaKafkaVersion   = "2.0.7"
-        jacksonVersion        = "2.10.5"
+        jacksonVersion        = "2.18.4"
         akkaVersion           = "2.6.14"
-        vavrVersion           = "0.10.3"
-        jooqVersion           = "3.17.4"
-        jooqAsyncVersion      = "2.0.0"
-        functionalJsonVersion = "1.0.3"
+        vavrVersion           = "0.10.6"
+        vavrJacksonVersion    = "0.10.3"
+        jooqVersion           = "3.20.4"
+        jooqAsyncVersion      = "2.4.0-rc1"
+        functionalJsonVersion = "1.0.5-rc1"
         kafkaVersion          = "3.0.1"
-        reactorKafkaVersion   = "1.3.22"
-        reactorVersion        = "3.5.7"
-        vertxSqlVersion       = "4.3.3"
+        reactorKafkaVersion   = "1.3.23"
+        reactorVersion        = "3.7.7"
+        vertxSqlVersion       = "5.0.0"
         testContainerVersion  = "1.21.1"
     }
 

commons-events/src/main/java/fr/maif/eventsourcing/Lazy.java

@@ -0,0 +1,23 @@
+package fr.maif.eventsourcing;
+
+import java.util.function.Supplier;
+
+public class Lazy<T> {
+    private final io.vavr.Lazy<T> inner;
+
+    private Lazy(io.vavr.Lazy<T> inner) {
+        this.inner = inner;
+    }
+
+    public T get() {
+        return inner.get();
+    }
+
+    public static <T> Lazy<T> of(Supplier<T> supplier) {
+        return new Lazy<>(io.vavr.Lazy.of(supplier));
+    }
+
+    public io.vavr.Lazy<T> toVavr() {
+        return inner;
+    }
+}

commons-events/src/main/java/fr/maif/eventsourcing/Result.java

@@ -0,0 +1,78 @@
+package fr.maif.eventsourcing;
+
+import io.vavr.control.Either;
+
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public sealed interface Result<E, V> {
+
+    record Success<E, V>(V value) implements Result<E, V> {}
+    record Error<E, V>(E value) implements Result<E, V> {}
+
+    static <E, V> Result<E, V> success(V value) {
+        return new Success<>(value);
+    }
+    static <E, V> Result<E, V> error(E value) {
+        return new Error<>(value);
+    }
+
+    static <E, V> Result<E, V> fromEither(Either<? extends E, ? extends V> either) {
+        return either.fold(Result::error, Result::success);
+    }
+
+    static <E, V> Result<E, V> fromOptional(Optional<V> optional, Supplier<E> onEmpty) {
+        return optional.map(v -> Result.<E, V>success(v)).orElseGet(() -> Result.<E, V>error(onEmpty.get()));
+    }
+
+    default V get() {
+        return switch (this) {
+            case Success(var value) -> value;
+            case Error(var err) -> throw new RuntimeException(err.toString());
+        };
+    }
+
+    default <U> Result<E, U> map(Function<V, U> f) {
+        return switch (this) {
+            case Success(var value) -> new Success<E, U>(f.apply(value));
+            case Error(var err) -> new Error<E, U>(err);
+        };
+    }
+    default <E1> Result<E1, V> mapError(Function<E, E1> f) {
+        return switch (this) {
+            case Success(var value) -> new Success<E1, V>(value);
+            case Error(var err) -> new Error<E1, V>(f.apply(err));
+        };
+    }
+
+    default Result<E, V> onError(Consumer<E> f) {
+        if (this instanceof Result.Error<E,V>(var err)) {
+            f.accept(err);
+        }
+        return this;
+    }
+
+    default Result<E, V> onSuccess(Consumer<V> f) {
+        if (this instanceof Result.Success<E,V>(var s)) {
+            f.accept(s);
+        }
+        return this;
+    }
+
+    default <U> Result<E, U> flatMap(Function<V, Result<E, U>> f) {
+        return switch (this) {
+            case Success(var value) -> f.apply(value);
+            case Error(var err) -> new Error<E, U>(err);
+        };
+    }
+
+    default <U> U fold(Function<E, U> onError, Function<V, U> onSuccess) {
+        return switch (this) {
+            case Success(var value) -> onSuccess.apply(value);
+            case Error(var err) -> onError.apply(err);
+        };
+    }
+
+}

commons-events/src/main/java/fr/maif/eventsourcing/Unit.java

@@ -0,0 +1,13 @@
+package fr.maif.eventsourcing;
+
+public class Unit {
+
+    public static Unit unit = new Unit();
+
+    public static Unit unit() {
+        return unit;
+    }
+
+    private Unit() {
+    }
+}

demo/demo-in-memory-vanilla/build.gradle

@@ -0,0 +1,27 @@
+
+
+
+tasks.withType(PublishToMavenRepository).configureEach { it.enabled = false }
+/* Parametre de compilation java */
+compileJava {
+    // To enable argument names in reporting and debugging
+    options.compilerArgs += '-parameters'
+}
+
+compileTestJava {
+    // To enable argument names in reporting and debugging
+    options.compilerArgs += '-parameters'
+}
+
+dependencies {
+
+    implementation project(':commons-events')
+    implementation project(':thoth-core')
+    implementation project(':thoth-core-reactor')
+    implementation project(':thoth-kafka-consumer-reactor')
+    implementation("io.vavr:vavr:$vavrVersion")
+    implementation("fr.maif:functional-json:$functionalJsonVersion")
+    implementation("com.fasterxml.uuid:java-uuid-generator:4.0.1")
+    implementation('org.postgresql:postgresql:42.7.7')
+
+}

demo/demo-in-memory-vanilla/src/main/java/com/example/demo/Account.java

@@ -0,0 +1,27 @@
+package com.example.demo;
+
+import fr.maif.eventsourcing.AbstractState;
+
+import java.math.BigDecimal;
+
+public class Account extends AbstractState<Account> {
+    public String id;
+    public BigDecimal balance;
+    public long sequenceNum;
+
+    @Override
+    public Long sequenceNum() {
+        return sequenceNum;
+    }
+
+    @Override
+    public String entityId() {
+        return id;
+    }
+
+    @Override
+    public Account withSequenceNum(Long sequenceNum) {
+        this.sequenceNum = sequenceNum;
+        return this;
+    }
+}

demo/demo-in-memory-vanilla/src/main/java/com/example/demo/Bank.java

@@ -0,0 +1,78 @@
+package com.example.demo;
+
+import com.fasterxml.uuid.Generators;
+import com.fasterxml.uuid.impl.TimeBasedGenerator;
+import fr.maif.eventsourcing.Lazy;
+import fr.maif.eventsourcing.Result;
+import fr.maif.eventsourcing.TransactionManager;
+import fr.maif.eventsourcing.Unit;
+import fr.maif.eventsourcing.vanilla.*;
+import fr.maif.reactor.eventsourcing.vanilla.DefaultAggregateStore;
+import fr.maif.reactor.eventsourcing.vanilla.InMemoryEventStore;
+import fr.maif.reactor.eventsourcing.vanilla.InMemoryEventStore.Transaction;
+
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.function.Function;
+
+public class Bank {
+    private final EventProcessor<String, Account, BankCommand, BankEvent, Transaction<BankEvent, Unit, Unit>, Unit, Unit, Unit> eventProcessor;
+    private static final TimeBasedGenerator UUIDgenerator = Generators.timeBasedGenerator();
+
+
+    public Bank(
+                BankCommandHandler commandHandler,
+                BankEventHandler eventHandler) {
+
+        EventStore<Transaction<BankEvent, Unit, Unit>, BankEvent, Unit, Unit> eventStore = InMemoryEventStore.create();
+        TransactionManager<Transaction<BankEvent, Unit, Unit>> transactionManager = noOpTransactionManager();
+        ExecutorService executor = Executors.newCachedThreadPool();
+        DefaultAggregateStore<Account, BankEvent, Unit, Unit, Transaction<BankEvent, Unit, Unit>> aggregateStore = new DefaultAggregateStore<>(eventStore, eventHandler, transactionManager);
+        this.eventProcessor = new EventProcessorImpl<>(
+                eventStore,
+                transactionManager,
+                aggregateStore,
+                commandHandler.toCommandHandler(executor),
+                eventHandler,
+                List.of()
+        );
+    }
+
+    private TransactionManager<Transaction<BankEvent, Unit, Unit>> noOpTransactionManager() {
+        return new TransactionManager<>() {
+            @Override
+            public <T> CompletionStage<T> withTransaction(Function<Transaction<BankEvent, Unit, Unit>, CompletionStage<T>> function) {
+                return function.apply(new Transaction<>());
+            }
+        };
+    }
+
+    public CompletionStage<Result<String, ProcessingSuccess<Account, BankEvent, Unit, Unit, Unit>>> createAccount(
+            BigDecimal amount) {
+        Lazy<String> lazyId = Lazy.of(() -> UUIDgenerator.generate().toString());
+        return eventProcessor.processCommand(new BankCommand.OpenAccount(lazyId, amount));
+    }
+
+    public CompletionStage<Result<String, ProcessingSuccess<Account, BankEvent, Unit, Unit, Unit>>> withdraw(
+            String account, BigDecimal amount) {
+        return eventProcessor.processCommand(new BankCommand.Withdraw(account, amount));
+    }
+
+    public CompletionStage<Result<String, ProcessingSuccess<Account, BankEvent, Unit, Unit, Unit>>> deposit(
+            String account, BigDecimal amount) {
+        return eventProcessor.processCommand(new BankCommand.Deposit(account, amount));
+    }
+
+    public CompletionStage<Result<String, ProcessingSuccess<Account, BankEvent, Unit, Unit, Unit>>> close(
+            String account) {
+        return eventProcessor.processCommand(new BankCommand.CloseAccount(account));
+    }
+
+    public CompletionStage<Optional<Account>> findAccountById(String id) {
+        return eventProcessor.getAggregate(id);
+    }
+}

demo/demo-in-memory-vanilla/src/main/java/com/example/demo/BankCommand.java

@@ -0,0 +1,43 @@
+package com.example.demo;
+
+import fr.maif.eventsourcing.Lazy;
+import fr.maif.eventsourcing.vanilla.SimpleCommand;
+
+import java.math.BigDecimal;
+
+public sealed interface BankCommand extends SimpleCommand {
+
+    record Withdraw(String account, BigDecimal amount) implements BankCommand {
+        @Override
+        public Lazy<String> getEntityId() {
+            return Lazy.of(() -> account);
+        }
+    }
+
+    record OpenAccount(Lazy<String> id, BigDecimal initialBalance) implements BankCommand {
+
+        @Override
+        public Lazy<String> getEntityId() {
+            return id;
+        }
+
+        @Override
+        public Boolean hasId() {
+            return false;
+        }
+    }
+
+    record Deposit(String account, BigDecimal amount) implements BankCommand {
+        @Override
+        public Lazy<String> getEntityId() {
+            return Lazy.of(() -> account);
+        }
+    }
+
+    record CloseAccount(String id) implements BankCommand {
+        @Override
+        public Lazy<String> getEntityId() {
+            return Lazy.of(() -> id);
+        }
+    }
+}