The endpoint that measured one query

import java.util.*;

/**
 * Solution: the endpoint that measured one query.
 *
 * Three defects, in three different places: a mapping default nobody wrote, a
 * framework default nobody chose, and a service that returned entities it had
 * not finished loading. Only the first is visible in the entity class, which
 * is why reading the mappings was never going to find this.
 */
public class Solution {

    enum Fetch { LAZY, EAGER }

    static final class LazyInitException extends RuntimeException {
        LazyInitException(String name) { super("could not initialize proxy [" + name + "] - no Session"); }
    }

    /* ── the persistence context (correct; do not change) ───────────────── */

    static final class Session {
        boolean open = true;
        int queriesInService, queriesWhileRendering;
        boolean rendering;

        void run() { if (rendering) queriesWhileRendering++; else queriesInService++; }
        int total() { return queriesInService + queriesWhileRendering; }
    }

    static final class Association {
        final String name; final Session session; final int rows;
        boolean loaded;

        Association(Session session, String name, Fetch fetch, int rows) {
            this.session = session; this.name = name; this.rows = rows;
            if (fetch == Fetch.EAGER) { session.run(); loaded = true; }
        }

        int size() {
            if (loaded) return rows;
            if (!session.open) throw new LazyInitException(name);
            session.run();
            loaded = true;
            return rows;
        }

        void markLoaded() { loaded = true; }
    }

    static final class OrderEntity {
        final Association customer, items;
        OrderEntity(Association customer, Association items) {
            this.customer = customer; this.items = items;
        }
    }

    /* ── the mappings and the service under review ──────────────────────── */

    /*
     * Defect 1. The @ManyToOne had no fetch type written, so it took the JPA
     * default — EAGER — and fetched a customer for every order on every query
     * that returned one, including this page, which only needs a name.
     *
     * A to-one association should always say LAZY explicitly. The default was
     * chosen for loading a single entity and is wrong for every list.
     */
    static final Fetch CUSTOMER_FETCH = Fetch.LAZY;    // @ManyToOne(fetch = LAZY)
    static final Fetch ITEMS_FETCH    = Fetch.LAZY;    // @OneToMany, already lazy

    /*
     * Defect 2. spring.jpa.open-in-view defaults to true, which kept the
     * session alive through rendering — so the twenty lazy loads succeeded,
     * after the transaction had committed and after the instrumentation on the
     * service method had stopped. That is why the service honestly reported
     * one query while the request issued forty-one.
     *
     * Turning it off does not make anything faster by itself. It makes the
     * cost visible, by turning a silent query into an exception.
     */
    static final boolean OPEN_IN_VIEW = false;

    record OrderView(long id, String customerName, int itemCount) {}

    static final class OrderService {
        final Session session;
        OrderService(Session session) { this.session = session; }

        /*
         * Defect 3. With open-in-view off, returning entities whose
         * collections were never loaded means the renderer throws. The service
         * has to finish what it started: load, in one query, exactly the
         * associations the response needs.
         *
         * This is @EntityGraph or a join fetch in real code. Two queries, both
         * inside the transaction, both deliberate.
         *
         * The stronger fix is to return a DTO rather than an entity, so
         * nothing that needs a session crosses the boundary at all — then the
         * open-in-view setting stops mattering to this endpoint entirely.
         */
        List<OrderEntity> listPage(int size) {
            session.run();                                   // select o from Order o
            var page = new ArrayList<OrderEntity>();
            for (int i = 0; i < size; i++)
                page.add(new OrderEntity(
                    new Association(session, "order.customer", CUSTOMER_FETCH, 1),
                    new Association(session, "order.items", ITEMS_FETCH, 4)));

            session.run();                                   // one query for all the collections
            for (OrderEntity o : page) { o.items.markLoaded(); o.customer.markLoaded(); }
            return page;
        }
    }

    /** The controller and serialiser, running after the service returns. */
    static List<OrderView> render(Session session, List<OrderEntity> orders) {
        session.rendering = true;
        if (!OPEN_IN_VIEW) session.open = false;
        var views = new ArrayList<OrderView>();
        long id = 1;
        for (OrderEntity o : orders)
            views.add(new OrderView(id++, "customer-" + id, o.items.size()));
        return views;
    }

    /* ── checks ─────────────────────────────────────────────────────────── */

    static final int PAGE = 20;

    public static void main(String[] args) {
        List<String> failures = new ArrayList<>();

        var session = new Session();
        var service = new OrderService(session);
        List<OrderView> views;
        try {
            views = render(session, service.listPage(PAGE));
        } catch (LazyInitException e) {
            views = List.of();
            failures.add("0. the request threw: " + e.getMessage());
        }

        // 1. Loading a page must not fetch associations nobody asked for.
        if (session.queriesInService > 2)
            failures.add("1. the service issued " + session.queriesInService + " queries for " + PAGE
                       + " orders — an association is being fetched with the parent");

        // 2. Nothing may query the database after the service has returned.
        if (session.queriesWhileRendering > 0)
            failures.add("2. " + session.queriesWhileRendering + " queries were issued while rendering, "
                       + "after the transaction committed — a timer on the service would report none of them");

        // 3. The whole request must be a small constant number of queries.
        if (session.total() > 2)
            failures.add("3. the request took " + session.total() + " queries for " + PAGE + " orders");

        // 4. And it must actually produce the page.
        if (views.size() != PAGE)
            failures.add("4. rendered " + views.size() + " views, expected " + PAGE);

        /* ── report ─────────────────────────────────────────────────────── */
        if (failures.isEmpty()) {
            System.out.println("PASS");
        } else {
            failures.forEach(f -> System.out.println("  " + f));
            System.out.println("FAIL");
        }
    }
}