package com.lectures.business.design.sales.persistence;

public class RepositoryException extends RuntimeException {

    public RepositoryException(String message, Throwable cause) {
        super(message, cause);
    }
}

package com.lectures.business.design.sales.persistence;

import com.lectures.business.design.sales.domain.CustomerId;
import com.lectures.business.design.sales.domain.Order;
import com.lectures.business.design.sales.domain.OrderId;
import com.lectures.business.design.sales.domain.OrderLine;
import com.lectures.business.design.sales.domain.OrderStatus;
import com.lectures.business.design.shared.kernel.Address;
import com.lectures.business.design.shared.kernel.Money;
import com.lectures.business.design.shared.kernel.Specification;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Currency;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import javax.sql.DataSource;

public final class JdbcOrderRepository implements OrderRepository {

    private static final String ORDER_COLUMNS = """
            order_id, customer_id, order_date, status,
            ship_street, ship_city, ship_postal_code, ship_country, shipped_date
            """;
    private static final String LINE_COLUMNS
            = "order_id, line_no, product_id, unit_price, currency, quantity, discount";

    private static final String UPDATE_ORDER = """
            UPDATE orders
               SET customer_id = ?, order_date = ?, status = ?,
                   ship_street = ?, ship_city = ?, ship_postal_code = ?, ship_country = ?,
                   shipped_date = ?
             WHERE order_id = ?
            """;
    private static final String INSERT_ORDER = """
            INSERT INTO orders (customer_id, order_date, status,
                                ship_street, ship_city, ship_postal_code, ship_country,
                                shipped_date, order_id)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
            """;
    private static final String DELETE_LINES = "DELETE FROM order_lines WHERE order_id = ?";
    private static final String INSERT_LINE
            = "INSERT INTO order_lines (" + LINE_COLUMNS + ") VALUES (?, ?, ?, ?, ?, ?, ?)";

    private final DataSource dataSource;

    public JdbcOrderRepository(DataSource dataSource) {
        this.dataSource = Objects.requireNonNull(dataSource, "dataSource must not be null");
    }

    @Override
    public void save(Order order) {
        Objects.requireNonNull(order, "order must not be null");
        try (Connection connection = dataSource.getConnection()) {
            connection.setAutoCommit(false);
            try {
                if (writeOrder(connection, UPDATE_ORDER, order) == 0) {
                    writeOrder(connection, INSERT_ORDER, order);
                }
                replaceLines(connection, order);
                connection.commit();
            } catch (SQLException | RuntimeException e) {
                connection.rollback();
                throw e;
            }
        } catch (SQLException e) {
            throw new RepositoryException("could not save order " + order.orderId(), e);
        }
    }

    @Override
    public Optional<Order> findById(OrderId orderId) {
        List<Order> found = query(" WHERE order_id = ?", orderId.value());
        return found.stream().findFirst();
    }

    @Override
    public List<Order> findAll() {
        return query("", null);
    }

    @Override
    public List<Order> findAll(Specification<Order> specification) {
        Objects.requireNonNull(specification, "specification must not be null");
        // Honest but expensive: every order is loaded, then filtered in memory.
        // Turning a Specification into a WHERE clause is what JPA Criteria does for us.
        return findAll().stream()
                .filter(specification::isSatisfiedBy)
                .toList();
    }

    @Override
    public long count() {
        try (Connection connection = dataSource.getConnection(); PreparedStatement statement = connection.prepareStatement("SELECT COUNT(*) FROM orders"); ResultSet rs = statement.executeQuery()) {
            rs.next();
            return rs.getLong(1);
        } catch (SQLException e) {
            throw new RepositoryException("could not count orders", e);
        }
    }

    // --- writing ---
    private static int writeOrder(Connection connection, String sql, Order order) throws SQLException {
        try (PreparedStatement statement = connection.prepareStatement(sql)) {
            Optional<Address> address = order.shippingAddress();
            statement.setString(1, order.customerId().value());
            statement.setObject(2, order.orderDate());
            statement.setString(3, order.status().name());
            statement.setString(4, address.map(Address::street).orElse(null));
            statement.setString(5, address.map(Address::city).orElse(null));
            statement.setString(6, address.map(Address::postalCode).orElse(null));
            statement.setString(7, address.map(Address::country).orElse(null));
            statement.setObject(8, order.shippedDate().orElse(null));
            statement.setInt(9, order.orderId().value());
            return statement.executeUpdate();
        }
    }

    private static void replaceLines(Connection connection, Order order) throws SQLException {
        try (PreparedStatement delete = connection.prepareStatement(DELETE_LINES)) {
            delete.setInt(1, order.orderId().value());
            delete.executeUpdate();
        }
        try (PreparedStatement insert = connection.prepareStatement(INSERT_LINE)) {
            int lineNo = 1;
            for (OrderLine line : order.lines()) {
                insert.setInt(1, order.orderId().value());
                insert.setInt(2, lineNo++);
                insert.setInt(3, line.productId());
                insert.setBigDecimal(4, line.unitPrice().amount());
                insert.setString(5, line.unitPrice().currency().getCurrencyCode());
                insert.setInt(6, line.quantity());
                insert.setBigDecimal(7, line.discount());
                insert.addBatch();
            }
            insert.executeBatch();
        }
    }

    private List<Order> query(String where, Integer orderId) {
        String orderSql = "SELECT " + ORDER_COLUMNS + " FROM orders" + where + " ORDER BY order_id";
        String lineSql = "SELECT " + LINE_COLUMNS + " FROM order_lines" + where + " ORDER BY order_id, line_no";

        try (Connection connection = dataSource.getConnection()) {
            Map<Integer, List<OrderLine>> lines = readLines(connection, lineSql, orderId);
            List<Order> orders = new ArrayList<>();
            try (PreparedStatement statement = connection.prepareStatement(orderSql)) {
                if (orderId != null) {
                    statement.setInt(1, orderId);
                }
                try (ResultSet rs = statement.executeQuery()) {
                    while (rs.next()) {
                        orders.add(toOrder(rs, lines.getOrDefault(rs.getInt("order_id"), List.of())));
                    }
                }
            }
            return List.copyOf(orders);
        } catch (SQLException e) {
            throw new RepositoryException("could not load orders", e);
        }
    }

    private static Map<Integer, List<OrderLine>> readLines(Connection connection, String sql, Integer orderId)
            throws SQLException {
        Map<Integer, List<OrderLine>> lines = new HashMap<>();
        try (PreparedStatement statement = connection.prepareStatement(sql)) {
            if (orderId != null) {
                statement.setInt(1, orderId);
            }
            try (ResultSet rs = statement.executeQuery()) {
                while (rs.next()) {
                    lines.computeIfAbsent(rs.getInt("order_id"), id -> new ArrayList<>())
                            .add(new OrderLine(
                                    rs.getInt("product_id"),
                                    new Money(rs.getBigDecimal("unit_price"),
                                            Currency.getInstance(rs.getString("currency"))),
                                    rs.getInt("quantity"),
                                    rs.getBigDecimal("discount")));
                }
            }
        }
        return lines;
    }

    private static Order toOrder(ResultSet rs, List<OrderLine> lines) throws SQLException {
        String street = rs.getString("ship_street");
        Address address = street == null ? null : new Address(street, rs.getString("ship_city"),
                rs.getString("ship_postal_code"), rs.getString("ship_country"));

        return Order.reconstitute(
                OrderId.of(rs.getInt("order_id")),
                CustomerId.of(rs.getString("customer_id")),
                rs.getObject("order_date", LocalDate.class),
                OrderStatus.valueOf(rs.getString("status")),
                address,
                rs.getObject("shipped_date", LocalDate.class),
                lines);
    }
}

@Override
public void save(Order order) {
    Objects.requireNonNull(order, "order must not be null");
    try (Connection connection = dataSource.getConnection()) {
        connection.setAutoCommit(false);
        try {
            if (writeOrder(connection, UPDATE_ORDER, order) == 0) {
                writeOrder(connection, INSERT_ORDER, order);
            }
            replaceLines(connection, order);
            connection.commit();
        } catch (SQLException | RuntimeException e) {
            connection.rollback();
            throw e;
        }
    } catch (SQLException e) {
        throw new RepositoryException("could not save order " + order.orderId(), e);
    }
}

Order order = new Order(id, customerId, orderDate);
order.shipTo(address);
lines.forEach(line -> order.addLine(...));
order.confirm();
order.ship(shippedDate);

public static Order reconstitute(OrderId orderId, CustomerId customerId, LocalDate orderDate,
        OrderStatus status, Address shippingAddress, LocalDate shippedDate, List<OrderLine> lines) {
    Order order = new Order(orderId, customerId, orderDate);
    order.status = Objects.requireNonNull(status, "status must not be null");
    order.shippingAddress = shippingAddress;
    order.shippedDate = shippedDate;
    order.lines.addAll(Objects.requireNonNull(lines, "lines must not be null"));
    if ((status == OrderStatus.SHIPPED) != (shippedDate != null)) {
        throw new IllegalStateException(
                "stored order " + orderId + " is corrupt: status " + status + ", shipped " + shippedDate);
    }
    return order;
}

@Override
public List<Order> findAll(Specification<Order> specification) {
    Objects.requireNonNull(specification, "specification must not be null");
    return findAll().stream()
            .filter(specification::isSatisfiedBy)
            .toList();
}

package com.lectures.business.design.sales.persistence;

import com.lectures.business.design.sales.domain.Customer;
import com.lectures.business.design.sales.domain.CustomerId;
import com.lectures.business.design.shared.kernel.Address;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Objects;
import java.util.Optional;
import javax.sql.DataSource;

public final class JdbcCustomerRepository implements CustomerRepository {

    private static final String UPDATE_CUSTOMER = """
            UPDATE customers
               SET company_name = ?, contact_name = ?, street = ?, city = ?, postal_code = ?, country = ?
             WHERE customer_id = ?
            """;
    private static final String INSERT_CUSTOMER = """
            INSERT INTO customers (company_name, contact_name, street, city, postal_code, country, customer_id)
            VALUES (?, ?, ?, ?, ?, ?, ?)
            """;
    private static final String SELECT_CUSTOMER = """
            SELECT customer_id, company_name, contact_name, street, city, postal_code, country
              FROM customers
             WHERE customer_id = ?
            """;

    private final DataSource dataSource;

    public JdbcCustomerRepository(DataSource dataSource) {
        this.dataSource = Objects.requireNonNull(dataSource, "dataSource must not be null");
    }

    @Override
    public void save(Customer customer) {
        Objects.requireNonNull(customer, "customer must not be null");
        try (Connection connection = dataSource.getConnection()) {
            if (writeCustomer(connection, UPDATE_CUSTOMER, customer) == 0) {
                writeCustomer(connection, INSERT_CUSTOMER, customer);
            }
        } catch (SQLException e) {
            throw new RepositoryException("could not save customer " + customer.customerId(), e);
        }
    }

    @Override
    public Optional<Customer> findById(CustomerId customerId) {
        Objects.requireNonNull(customerId, "customerId must not be null");
        try (Connection connection = dataSource.getConnection(); PreparedStatement statement = connection.prepareStatement(SELECT_CUSTOMER)) {
            statement.setString(1, customerId.value());
            try (ResultSet rs = statement.executeQuery()) {
                return rs.next() ? Optional.of(toCustomer(rs)) : Optional.empty();
            }
        } catch (SQLException e) {
            throw new RepositoryException("could not load customer " + customerId, e);
        }
    }

    private static int writeCustomer(Connection connection, String sql, Customer customer) throws SQLException {
        try (PreparedStatement statement = connection.prepareStatement(sql)) {
            Address address = customer.address();
            statement.setString(1, customer.companyName());
            statement.setString(2, customer.contactName().orElse(null));
            statement.setString(3, address.street());
            statement.setString(4, address.city());
            statement.setString(5, address.postalCode());
            statement.setString(6, address.country());
            statement.setString(7, customer.customerId().value());
            return statement.executeUpdate();
        }
    }

    private static Customer toCustomer(ResultSet rs) throws SQLException {
        Customer customer = new Customer(
                CustomerId.of(rs.getString("customer_id")),
                rs.getString("company_name"),
                new Address(rs.getString("street"), rs.getString("city"),
                        rs.getString("postal_code"), rs.getString("country")));
        String contact = rs.getString("contact_name");
        if (contact != null) {
            customer.assignContact(contact);
        }
        return customer;
    }
}

package com.lectures.business.design.sales.persistence;

import java.util.UUID;
import javax.sql.DataSource;
import org.flywaydb.core.Flyway;
import org.h2.jdbcx.JdbcDataSource;

public final class TestDatabases {

    private TestDatabases() {
    }

    public static DataSource h2() {
        JdbcDataSource dataSource = new JdbcDataSource();
        dataSource.setURL("jdbc:h2:mem:sales-" + UUID.randomUUID()
                + ";MODE=PostgreSQL;DATABASE_TO_LOWER=TRUE;DEFAULT_NULL_ORDERING=HIGH;DB_CLOSE_DELAY=-1");
        dataSource.setUser("sa");
        return migrate(dataSource);
    }

    public static DataSource migrate(DataSource dataSource) {
        Flyway.configure()
                .dataSource(dataSource)
                .locations("classpath:db/migration/sales")
                .load()
                .migrate();
        return dataSource;
    }
}

package com.lectures.business.design.sales.persistence;

import com.lectures.business.design.sales.domain.CustomerId;
import com.lectures.business.design.sales.domain.Order;
import com.lectures.business.design.sales.domain.OrderBuilder;
import com.lectures.business.design.sales.domain.OrderId;
import com.lectures.business.design.sales.domain.OrderNotFoundException;
import com.lectures.business.design.sales.domain.OrderSpecifications;
import com.lectures.business.design.sales.domain.OrderStatus;
import com.lectures.business.design.shared.kernel.Address;
import com.lectures.business.design.shared.kernel.Money;
import java.math.BigDecimal;
import java.time.LocalDate;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

abstract class OrderRepositoryContract {

    protected OrderRepository repository;

    protected abstract OrderRepository createRepository();

    @BeforeEach
    void setUpContract() {
        repository = createRepository();
        repository.save(OrderBuilder.anOrder()
                .withId(10248).forCustomer("VINET").withLine(11, "14.00", 10).shipped().build());
        repository.save(OrderBuilder.anOrder()
                .withId(10249).forCustomer("VINET").withLine(11, "10.00", 3).confirmed().build());
        repository.save(OrderBuilder.anOrder()
                .withId(10250).forCustomer("TOMSP").withLine(11, "99.00", 5).cancelled().build());
        repository.save(OrderBuilder.anOrder()
                .withId(10251).forCustomer("TOMSP").withLine(11, "20.00", 4).build());
    }

    @Test
    @DisplayName("findById answers with an Optional, getById with an exception")
    void findByIdAndGetById() {
        assertThat(repository.findById(OrderId.of(10248))).isPresent();
        assertThat(repository.findById(OrderId.of(99999))).isEmpty();
        assertThatThrownBy(() -> repository.getById(OrderId.of(99999)))
                .isInstanceOf(OrderNotFoundException.class);
    }

    @Test
    @DisplayName("an aggregate comes back exactly as it was saved")
    void roundTripKeepsEveryField() {
        Order original = OrderBuilder.anOrder()
                .withId(10260).forCustomer("TOMSP").orderedOn(LocalDate.of(1996, 7, 19))
                .shippingTo(new Address("Luisenstr. 48", "Munster", "44087", "Germany"))
                .withLine(11, "14.00", 12)
                .withDiscountedLine(42, "9.80", 10, "0.1")
                .shipped().build();
        repository.save(original);

        Order loaded = repository.getById(OrderId.of(10260));

        assertThat(loaded.customerId()).isEqualTo(CustomerId.of("TOMSP"));
        assertThat(loaded.orderDate()).isEqualTo(LocalDate.of(1996, 7, 19));
        assertThat(loaded.status()).isEqualTo(OrderStatus.SHIPPED);
        assertThat(loaded.shippedDate()).isEqualTo(original.shippedDate());
        assertThat(loaded.shippingAddress()).isEqualTo(original.shippingAddress());
        assertThat(loaded.lines()).isEqualTo(original.lines());
        assertThat(loaded.total()).isEqualTo(original.total());
    }

    @Test
    @DisplayName("a change that is not saved is not stored")
    void unsavedChangesAreLost() {
        Order order = repository.getById(OrderId.of(10249));
        order.cancel();

        assertThat(repository.getById(OrderId.of(10249)).status()).isEqualTo(OrderStatus.CONFIRMED);

        repository.save(order);
        assertThat(repository.getById(OrderId.of(10249)).status()).isEqualTo(OrderStatus.CANCELLED);
    }

    @Test
    @DisplayName("save replaces by identity: lines that left the aggregate leave the store")
    void saveIsUpsertOfTheWholeAggregate() {
        Order draft = repository.getById(OrderId.of(10251));
        draft.addLine(42, Money.tl("9.80"), 1, BigDecimal.ZERO);
        draft.removeLine(11);
        repository.save(draft);

        assertThat(repository.count()).isEqualTo(4);
        assertThat(repository.getById(OrderId.of(10251)).productIds()).containsExactly(42);
    }

    @Test
    @DisplayName("a loaded aggregate announces nothing: reconstitution is not a business event")
    void loadingRaisesNoEvents() {
        assertThat(repository.getById(OrderId.of(10248)).pullEvents()).isEmpty();
    }

    @Test
    @DisplayName("findAll returns every aggregate as an unmodifiable list")
    void findAllReturnsEverything() {
        assertThat(repository.findAll())
                .isUnmodifiable()
                .extracting(order -> order.orderId().value())
                .containsExactlyInAnyOrder(10248, 10249, 10250, 10251);
    }

    @Test
    @DisplayName("specifications select and combine, ordered by id")
    void specificationDrivesTheQuery() {
        assertThat(repository.findAll(OrderSpecifications.placedBy(CustomerId.of("VINET"))))
                .extracting(order -> order.orderId().value())
                .containsExactly(10248, 10249);
        assertThat(repository.findAll(OrderSpecifications.placedBy(CustomerId.of("ALFKI")))).isEmpty();
        assertThat(repository.findAll(OrderSpecifications.notCancelled()
                .and(OrderSpecifications.placedBy(CustomerId.of("TOMSP")))))
                .extracting(order -> order.orderId().value())
                .containsExactly(10251);
    }

    @Test
    @DisplayName("an empty repository answers without blowing up")
    void emptyRepository() {
        OrderRepository empty = createRepository();
        assertThat(empty.count()).isZero();
        assertThat(empty.findAll()).isEmpty();
        assertThat(empty.findAll(OrderSpecifications.notCancelled())).isEmpty();
        assertThat(empty.findById(OrderId.of(10248))).isEmpty();
    }
}

package com.lectures.business.design.sales.persistence;

class InMemoryOrderRepositoryTest extends OrderRepositoryContract {

    @Override
    protected OrderRepository createRepository() {
        return new InMemoryOrderRepository();
    }
}

package com.lectures.business.design.sales.persistence;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import com.lectures.business.design.sales.domain.Customer;
import com.lectures.business.design.sales.domain.CustomerId;
import com.lectures.business.design.sales.domain.OrderBuilder;
import com.lectures.business.design.sales.domain.OrderId;
import com.lectures.business.design.shared.kernel.Address;

class JdbcOrderRepositoryTest extends OrderRepositoryContract {

    private DataSource dataSource;

    static void seedCustomers(DataSource dataSource) {
        CustomerRepository customers = new JdbcCustomerRepository(dataSource);
        customers.save(new Customer(CustomerId.of("VINET"), "Vins et alcools Chevalier",
                new Address("59 rue de l'Abbaye", "Reims", "51100", "France")));
        customers.save(new Customer(CustomerId.of("TOMSP"), "Toms Spezialitaten",
                new Address("Luisenstr. 48", "Munster", "44087", "Germany")));
    }

    @Override
    protected OrderRepository createRepository() {
        dataSource = TestDatabases.h2();
        seedCustomers(dataSource);
        return new JdbcOrderRepository(dataSource);
    }

    @Test
    @DisplayName("the foreign key refuses an order for a customer that does not exist")
    void unknownCustomerIsRejectedByTheDatabase() {
        assertThatThrownBy(() -> repository.save(OrderBuilder.anOrder()
                .withId(10300).forCustomer("ALFKI").withLine(11, "14.00", 1).build()))
                .isInstanceOf(RepositoryException.class)
                .hasRootCauseInstanceOf(SQLException.class);
    }

    @Test
    @DisplayName("a failed save leaves no half-written aggregate behind")
    void saveIsAtomic() throws SQLException {
        try (Connection connection = dataSource.getConnection(); Statement statement = connection.createStatement()) {
            statement.execute("ALTER TABLE order_lines ADD CONSTRAINT ck_sabotage CHECK (quantity <> 7)");
        }

        assertThatThrownBy(() -> repository.save(OrderBuilder.anOrder()
                .withId(10301).forCustomer("VINET").withLine(11, "14.00", 7).build()))
                .isInstanceOf(RepositoryException.class);
        assertThat(repository.findById(OrderId.of(10301))).isEmpty();
        assertThat(repository.count()).isEqualTo(4);
    }
}

package com.lectures.business.design.sales.persistence;

import com.lectures.business.design.sales.domain.Order;
import com.lectures.business.design.sales.domain.OrderId;
import com.lectures.business.design.shared.kernel.Specification;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;

public final class InMemoryOrderRepository implements OrderRepository {

    private final Map<OrderId, Order> orders = new LinkedHashMap<>();

    @Override
    public void save(Order order) {
        Objects.requireNonNull(order, "order must not be null");
        orders.put(order.orderId(), copyOf(order));
    }

    @Override
    public Optional<Order> findById(OrderId orderId) {
        return Optional.ofNullable(orders.get(orderId)).map(InMemoryOrderRepository::copyOf);
    }

    @Override
    public List<Order> findAll() {
        return orders.values().stream().map(InMemoryOrderRepository::copyOf).toList();
    }

    @Override
    public List<Order> findAll(Specification<Order> specification) {
        Objects.requireNonNull(specification, "specification must not be null");
        return orders.values().stream()
                .filter(specification::isSatisfiedBy)
                .sorted(Comparator.comparing(Order::orderId))
                .map(InMemoryOrderRepository::copyOf)
                .toList();
    }

    @Override
    public long count() {
        return orders.size();
    }

    private static Order copyOf(Order order) {
        return Order.reconstitute(order.orderId(), order.customerId(), order.orderDate(),
                order.status(), order.shippingAddress().orElse(null),
                order.shippedDate().orElse(null), order.lines());
    }
}

package com.lectures.business.design.sales.persistence;

import com.lectures.business.design.sales.domain.Customer;
import com.lectures.business.design.sales.domain.CustomerId;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;

public final class InMemoryCustomerRepository implements CustomerRepository {

    private final Map<CustomerId, Customer> customers = new HashMap<>();

    @Override
    public void save(Customer customer) {
        Objects.requireNonNull(customer, "customer must not be null");
        customers.put(customer.customerId(), copyOf(customer));
    }

    @Override
    public Optional<Customer> findById(CustomerId customerId) {
        return Optional.ofNullable(customers.get(customerId)).map(InMemoryCustomerRepository::copyOf);
    }

    private static Customer copyOf(Customer customer) {
        Customer copy = new Customer(customer.customerId(), customer.companyName(), customer.address());
        customer.contactName().ifPresent(copy::assignContact);
        return copy;
    }
}

package com.lectures.business.design.sales.domain;

import com.lectures.business.design.shared.kernel.Money;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Objects;

public record OrderLine(int productId, Money unitPrice, int quantity, BigDecimal discount) {

    private static final int DISCOUNT_SCALE = 2;

    public OrderLine {
        if (productId <= 0) {
            throw new IllegalArgumentException("productId must be positive: " + productId);
        }
        Objects.requireNonNull(unitPrice, "unitPrice must not be null");
        if (quantity <= 0) {
            throw new IllegalArgumentException("quantity must be positive: " + quantity);
        }
        Objects.requireNonNull(discount, "discount must not be null");
        if (discount.signum() < 0 || discount.compareTo(BigDecimal.ONE) > 0) {
            throw new IllegalArgumentException("discount must be within [0, 1]: " + discount);
        }
        try {
            discount = discount.setScale(DISCOUNT_SCALE, RoundingMode.UNNECESSARY);
        } catch (ArithmeticException e) {
            throw new IllegalArgumentException("discount has more than " + DISCOUNT_SCALE
                    + " decimal places: " + discount, e);
        }
    }

    public Money lineTotal() {
        return unitPrice.times(quantity).discountedBy(discount);
    }

    public OrderLine withAdditionalQuantity(int extra) {
        return new OrderLine(productId, unitPrice, quantity + extra, discount);
    }
}

package com.lectures.business.design.sales.persistence;

import com.lectures.business.design.sales.domain.Customer;
import com.lectures.business.design.sales.domain.CustomerId;
import com.lectures.business.design.sales.domain.CustomerNotFoundException;
import com.lectures.business.design.shared.kernel.Address;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

class CustomerRepositoryContractTest {

    static Stream<Arguments> repositories() {
        return Stream.of(
                Arguments.of("in-memory", (Supplier<CustomerRepository>) InMemoryCustomerRepository::new),
                Arguments.of("jdbc-h2", (Supplier<CustomerRepository>) ()
                        -> new JdbcCustomerRepository(TestDatabases.h2())));
    }

    @ParameterizedTest(name = "{0}")
    @MethodSource("repositories")
    @DisplayName("customers are found by their typed id")
    void findAndGet(String name, Supplier<CustomerRepository> factory) {
        CustomerRepository repository = factory.get();
        repository.save(new Customer(CustomerId.of("TOMSP"), "Toms Spezialitaten",
                new Address("Luisenstr. 48", "Munster", "44087", "Germany")));

        assertThat(repository.findById(CustomerId.of("tomsp"))).isPresent();
        assertThat(repository.findById(CustomerId.of("ALFKI"))).isEmpty();
        assertThatThrownBy(() -> repository.getById(CustomerId.of("ALFKI")))
                .isInstanceOf(CustomerNotFoundException.class);
    }

    @ParameterizedTest(name = "{0}")
    @MethodSource("repositories")
    @DisplayName("an unsaved relocation is not stored, a saved one is")
    void savingIsExplicit(String name, Supplier<CustomerRepository> factory) {
        CustomerRepository repository = factory.get();
        repository.save(new Customer(CustomerId.of("VINET"), "Vins et alcools Chevalier",
                new Address("59 rue de l'Abbaye", "Reims", "51100", "France")));

        Customer customer = repository.getById(CustomerId.of("VINET"));
        customer.relocateTo(new Address("2 rue du Commerce", "Lyon", "69004", "France"));
        customer.assignContact("Paul Henriot");
        assertThat(repository.getById(CustomerId.of("VINET")).address().city()).isEqualTo("Reims");

        repository.save(customer);
        Customer reloaded = repository.getById(CustomerId.of("VINET"));
        assertThat(reloaded.address().city()).isEqualTo("Lyon");
        assertThat(reloaded.contactName()).contains("Paul Henriot");
    }
}

package com.lectures.business.design.sales.persistence;

import javax.sql.DataSource;
import org.flywaydb.core.Flyway;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.postgresql.ds.PGSimpleDataSource;
import org.testcontainers.DockerClientFactory;
import org.testcontainers.postgresql.PostgreSQLContainer;
import static org.junit.jupiter.api.Assumptions.assumeTrue;

class PostgresOrderRepositoryTest extends OrderRepositoryContract {

    private static PostgreSQLContainer postgres;

    @BeforeAll
    static void startPostgres() {
        assumeTrue(DockerClientFactory.instance().isDockerAvailable(), "Docker is not available");
        postgres = new PostgreSQLContainer("postgres:17-alpine");
        postgres.start();
    }

    @AfterAll
    static void stopPostgres() {
        if (postgres != null) {
            postgres.stop();
        }
    }

    @Override
    protected OrderRepository createRepository() {
        PGSimpleDataSource dataSource = new PGSimpleDataSource();
        dataSource.setUrl(postgres.getJdbcUrl());
        dataSource.setUser(postgres.getUsername());
        dataSource.setPassword(postgres.getPassword());

        cleanAndMigrate(dataSource);
        JdbcOrderRepositoryTest.seedCustomers(dataSource);
        return new JdbcOrderRepository(dataSource);
    }

    private static void cleanAndMigrate(DataSource dataSource) {
        Flyway flyway = Flyway.configure()
                .dataSource(dataSource)
                .locations("classpath:db/migration/sales")
                .cleanDisabled(false)
                .load();
        flyway.clean();
        flyway.migrate();
    }
}

package com.lectures.business.design.sales.persistence;

import com.lectures.business.design.sales.domain.OrderId;
import com.lectures.business.design.sales.domain.OrderIdGenerator;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Objects;
import javax.sql.DataSource;

public final class SequenceOrderIdGenerator implements OrderIdGenerator {

    private final DataSource dataSource;

    public SequenceOrderIdGenerator(DataSource dataSource) {
        this.dataSource = Objects.requireNonNull(dataSource, "dataSource must not be null");
    }

    @Override
    public OrderId next() {
        try (Connection connection = dataSource.getConnection(); PreparedStatement statement = connection.prepareStatement("SELECT nextval('orders_seq')"); ResultSet rs = statement.executeQuery()) {
            rs.next();
            return OrderId.of(rs.getInt(1));
        } catch (SQLException e) {
            throw new RepositoryException("could not draw the next order id", e);
        }
    }
}

@Test
@DisplayName("ids come from the database sequence and survive a restart")
void sequenceHandsOutIds() {
    SequenceOrderIdGenerator first = new SequenceOrderIdGenerator(dataSource);
    SequenceOrderIdGenerator afterRestart = new SequenceOrderIdGenerator(dataSource);
    assertThat(first.next().value()).isEqualTo(10248);
    assertThat(afterRestart.next().value()).isEqualTo(10249);
}

package com.lectures.business.design.app;

import com.lectures.business.design.sales.application.CustomerNotifier;
import com.lectures.business.design.sales.application.InProcessEventPublisher;
import com.lectures.business.design.sales.application.OrderActivityLog;
import com.lectures.business.design.sales.application.OrderMapper;
import com.lectures.business.design.sales.application.OrderService;
import com.lectures.business.design.sales.application.SalesReport;
import com.lectures.business.design.sales.application.ShipmentNotificationHandler;
import com.lectures.business.design.sales.domain.OrderEvent;
import com.lectures.business.design.sales.domain.OrderFactory;
import com.lectures.business.design.sales.domain.OrderIdGenerator;
import com.lectures.business.design.sales.domain.OrderShipped;
import com.lectures.business.design.sales.domain.SequentialOrderIdGenerator;
import com.lectures.business.design.sales.persistence.CustomerRepository;
import com.lectures.business.design.sales.persistence.InMemoryCustomerRepository;
import com.lectures.business.design.sales.persistence.InMemoryOrderRepository;
import com.lectures.business.design.sales.persistence.JdbcCustomerRepository;
import com.lectures.business.design.sales.persistence.JdbcOrderRepository;
import com.lectures.business.design.sales.persistence.OrderRepository;
import com.lectures.business.design.sales.persistence.SequenceOrderIdGenerator;
import java.time.Clock;
import java.util.Objects;
import javax.sql.DataSource;

public final class SalesModule {

    private final CustomerRepository customers;
    private final OrderService orderService;
    private final SalesReport salesReport;
    private final OrderActivityLog activityLog = new OrderActivityLog();

    private SalesModule(OrderRepository orders, CustomerRepository customers, OrderIdGenerator ids,
            Clock clock, CustomerNotifier notifier) {
        this.customers = customers;

        InProcessEventPublisher publisher = new InProcessEventPublisher()
                .subscribe(OrderEvent.class, activityLog)
                .subscribe(OrderShipped.class, new ShipmentNotificationHandler(notifier));

        OrderMapper mapper = new OrderMapper();
        OrderFactory factory = new OrderFactory(ids, clock);

        this.orderService = new OrderService(orders, customers, factory, mapper, clock, publisher);
        this.salesReport = new SalesReport(orders, mapper);
    }

    public static SalesModule inMemory(Clock clock, int firstOrderId, CustomerNotifier notifier) {
        Objects.requireNonNull(clock, "clock must not be null");
        Objects.requireNonNull(notifier, "notifier must not be null");
        return new SalesModule(new InMemoryOrderRepository(), new InMemoryCustomerRepository(),
                new SequentialOrderIdGenerator(firstOrderId), clock, notifier);
    }

    public static SalesModule jdbc(DataSource dataSource, Clock clock, CustomerNotifier notifier) {
        Objects.requireNonNull(dataSource, "dataSource must not be null");
        Objects.requireNonNull(clock, "clock must not be null");
        Objects.requireNonNull(notifier, "notifier must not be null");
        return new SalesModule(new JdbcOrderRepository(dataSource), new JdbcCustomerRepository(dataSource),
                new SequenceOrderIdGenerator(dataSource), clock, notifier);
    }

    public CustomerRepository customers() {
        return customers;
    }

    public OrderService orderService() {
        return orderService;
    }

    public SalesReport salesReport() {
        return salesReport;
    }

    public OrderActivityLog activityLog() {
        return activityLog;
    }
}

package com.lectures.business.design.app;

import java.util.Map;
import java.util.UUID;
import javax.sql.DataSource;
import org.flywaydb.core.Flyway;
import org.h2.jdbcx.JdbcDataSource;
import org.postgresql.ds.PGSimpleDataSource;

final class Database {

    private Database() {
    }

    static DataSource fromEnvironment(Map<String, String> env) {
        String url = env.get("SALES_DB_URL");
        if (url == null || url.isBlank()) {
            return h2InMemory();
        }
        PGSimpleDataSource postgres = new PGSimpleDataSource();
        postgres.setUrl(url);
        postgres.setUser(env.getOrDefault("SALES_DB_USER", "johndoe"));
        postgres.setPassword(env.getOrDefault("SALES_DB_PASSWORD", ""));
        return postgres;
    }

    static DataSource h2InMemory() {
        JdbcDataSource h2 = new JdbcDataSource();
        h2.setURL("jdbc:h2:mem:sales-" + UUID.randomUUID()
                + ";MODE=PostgreSQL;DATABASE_TO_LOWER=TRUE;DEFAULT_NULL_ORDERING=HIGH;DB_CLOSE_DELAY=-1");
        h2.setUser("sa");
        return h2;
    }

    static DataSource migrated(DataSource dataSource) {
        Flyway.configure()
                .dataSource(dataSource)
                .locations("classpath:db/migration/sales")
                .load()
                .migrate();
        return dataSource;
    }
}

DataSource dataSource = Database.migrated(Database.fromEnvironment(System.getenv()));
SalesModule module = SalesModule.jdbc(dataSource, CLOCK, new ConsoleCustomerNotifier());

package com.lectures.business.design.app;

import com.lectures.business.design.sales.api.CustomerRevenue;
import com.lectures.business.design.sales.api.OrderLineRequest;
import com.lectures.business.design.sales.api.PlaceOrderCommand;
import com.lectures.business.design.sales.application.CustomerNotifier;
import com.lectures.business.design.sales.application.OrderService;
import com.lectures.business.design.sales.application.SteppingClock;
import com.lectures.business.design.sales.domain.Customer;
import com.lectures.business.design.sales.domain.CustomerId;
import com.lectures.business.design.shared.kernel.Address;
import java.math.BigDecimal;
import java.time.Clock;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.function.BiFunction;
import java.util.stream.Stream;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import static org.assertj.core.api.Assertions.assertThat;

class AppSmokeTest {

    static Stream<Arguments> wirings() {
        return Stream.of(
                Arguments.of("in-memory", (BiFunction<Clock, CustomerNotifier, SalesModule>) (clock, notifier)
                        -> SalesModule.inMemory(clock, 10248, notifier)),
                Arguments.of("jdbc-h2", (BiFunction<Clock, CustomerNotifier, SalesModule>) (clock, notifier)
                        -> SalesModule.jdbc(Database.migrated(Database.h2InMemory()), clock, notifier)));
    }

    @ParameterizedTest(name = "{0}")
    @MethodSource("wirings")
    @DisplayName("one scenario, two wirings: the use cases cannot tell memory from a database")
    void theWiredGraphWorksEndToEnd(String name, BiFunction<Clock, CustomerNotifier, SalesModule> wiring) {
        SteppingClock clock = new SteppingClock("1996-07-04T09:00:00Z");
        List<String> sent = new ArrayList<>();
        SalesModule module = wiring.apply(clock, (customerId, message) -> sent.add(customerId + ": " + message));
        module.customers().save(new Customer(CustomerId.of("VINET"), "Vins et alcools Chevalier",
                new Address("59 rue de l'Abbaye", "Reims", "51100", "France")));

        OrderService service = module.orderService();
        int shipped = service.placeOrder(new PlaceOrderCommand("VINET",
                List.of(OrderLineRequest.of(11, "14.00", 10)))).orderId();
        int cancelled = service.placeOrder(new PlaceOrderCommand("VINET",
                List.of(OrderLineRequest.of(11, "99.00", 5)))).orderId();

        service.confirm(shipped);
        clock.advance(Duration.ofDays(3));
        service.ship(shipped);
        service.cancel(cancelled);

        assertThat(module.salesReport().revenueByCustomer())
                .containsExactly(new CustomerRevenue("VINET", new BigDecimal("140.00"), "TRY"));
        assertThat(module.salesReport().countByStatus())
                .containsEntry("SHIPPED", 1L)
                .containsEntry("CANCELLED", 1L);
        assertThat(sent).containsExactly("VINET: Order 10248 shipped on 1996-07-07 to Reims");
        assertThat(module.activityLog().entries()).hasSize(3);
    }
}

//  ADR-0008 Persistence boundary
@ArchTest
static final ArchRule only_persistence_touches_jdbc = noClasses()
        .that().resideOutsideOfPackage("..sales.persistence..")
        .should().dependOnClassesThat().resideInAnyPackage("java.sql..", "javax.sql..");

@ArchTest
static final ArchRule only_persistence_reconstitutes = noClasses()
        .that().resideOutsideOfPackage("..sales.persistence..")
        .should().callMethod(Order.class, "reconstitute", OrderId.class, CustomerId.class,
                LocalDate.class, OrderStatus.class, Address.class, LocalDate.class, List.class);

@ArchTest
static final ArchRule repository_contracts_hide_sql_exceptions = noMethods()
        .that().areDeclaredInClassesThat().resideInAPackage("..sales.persistence..")
        .and().arePublic()
        .should().declareThrowableOfType(java.sql.SQLException.class);