The endpoint that returns maps instead of DTOs

import java.lang.reflect.*;
import java.util.*;

/**
 * Solution: the routing config client.
 *
 * Root cause, both tickets: a type argument does not exist at runtime.
 *
 *   Bug 1 — fetchAll() promised List<T> and had no T to build with, so it
 *           returned the wire maps and let the caller's compiler-inserted
 *           cast take the blame. The fix is to pass the type IN, because a
 *           Class<T> is a real runtime object where T is not.
 *
 *   Bug 2 — a raw Map reference switched type checking off, so a String
 *           entered a Map<String, List<RouteRule>> silently and the
 *           ClassCastException fired in whoever read it next. The fix is to
 *           delete the raw back door; the design fix is to make the write
 *           itself fail, which Collections.checkedMap does.
 */
public class Solution {

    record RouteRule(String path, int weight, boolean enabled) {}

    /* ─────────── the transport layer, unchanged ─────────── */

    static List<Map<String, Object>> wire() {
        return List.of(
                new LinkedHashMap<>(Map.of("path", "/orders", "weight", 10, "enabled", true)),
                new LinkedHashMap<>(Map.of("path", "/payments", "weight", 5, "enabled", true)),
                new LinkedHashMap<>(Map.of("path", "/legacy", "weight", 1, "enabled", false)));
    }

    @SuppressWarnings("unchecked")
    static <T> T toRecord(Map<String, Object> row, Class<T> target) {
        try {
            RecordComponent[] components = target.getRecordComponents();
            Class<?>[] types = new Class<?>[components.length];
            Object[] values = new Object[components.length];
            for (int i = 0; i < components.length; i++) {
                types[i] = components[i].getType();
                values[i] = row.get(components[i].getName());
            }
            return (T) target.getDeclaredConstructor(types).newInstance(values);
        } catch (ReflectiveOperationException e) {
            throw new IllegalStateException("cannot map " + row + " to " + target, e);
        }
    }

    /* ─────────── FIX 1a: pass the type in ─────────── */

    /**
     * A super type token. The empty braces at the call site create an
     * anonymous subclass, and that subclass's Signature attribute records the
     * full generic type — which getGenericSuperclass() reads back. This is
     * exactly how Jackson's TypeReference and Spring's
     * ParameterizedTypeReference work, and why both make you write the {}.
     */
    abstract static class TypeRef<T> {
        final Type type;

        TypeRef() {
            Type superclass = getClass().getGenericSuperclass();
            this.type = ((ParameterizedType) superclass).getActualTypeArguments()[0];
        }
    }

    static final class ConfigClient {

        /**
         * The plain fix, and the one to reach for by default: a Class<T> is a
         * real object, so the method has the type at runtime.
         */
        <T> List<T> fetchAll(Class<T> elementType) {
            List<T> out = new ArrayList<>();
            for (Map<String, Object> row : wire()) {
                out.add(toRecord(row, elementType));
            }
            return out;
        }

        /**
         * The token fix, needed when the type you want is itself generic and
         * so has no Class object — List<RouteRule> being the example.
         */
        @SuppressWarnings("unchecked")
        <T> List<T> fetchAll(TypeRef<List<T>> ref) {
            ParameterizedType listType = (ParameterizedType) ref.type;
            Class<T> elementType = (Class<T>) listType.getActualTypeArguments()[0];
            System.out.println("  token recovered element type: " + elementType.getSimpleName());
            return fetchAll(elementType);
        }
    }

    /* ─────────── FIX 2: close the raw back door ─────────── */

    static final class RuleCache {
        /**
         * checkedMap is the design answer, not just the fix. It carries the
         * Class objects the generic type could not, and rejects a bad value
         * AT THE WRITE — so the exception names the line that is actually
         * wrong instead of the next innocent reader.
         */
        @SuppressWarnings({"unchecked", "rawtypes"})
        private final Map<String, List<RouteRule>> byTenant =
                Collections.checkedMap(new HashMap<>(), String.class, (Class) List.class);

        void put(String tenant, List<RouteRule> rules) {
            byTenant.put(tenant, rules);
        }

        List<RouteRule> get(String tenant) {
            return byTenant.getOrDefault(tenant, List.of());
        }

        /** No raw reference, and nothing to pollute: a placeholder is empty. */
        void markPlaceholder(String tenant) {
            byTenant.putIfAbsent(tenant, List.of());
        }

        /** Only here to prove the back door is now loud rather than silent. */
        @SuppressWarnings({"rawtypes", "unchecked"})
        boolean rejectsWrongKeyType(String tenant) {
            Map raw = byTenant;
            try {
                raw.put(42, List.of());
                return false;
            } catch (ClassCastException e) {
                System.out.println("  raw write rejected at the write: "
                        + e.getClass().getSimpleName());
                return true;
            }
        }
    }

    public static void main(String[] args) {
        boolean rulesMapped = false;
        boolean cacheSafe = false;

        System.out.println("--- symptom 1: startup ---");
        ConfigClient client = new ConfigClient();
        List<RouteRule> rules = client.fetchAll(RouteRule.class);
        for (RouteRule rule : rules) {
            System.out.println("  route " + rule.path() + " weight " + rule.weight());
        }
        rulesMapped = rules.size() == 3 && rules.get(0).path().equals("/orders");

        System.out.println();
        System.out.println("--- the same call through a super type token ---");
        List<RouteRule> viaToken = client.fetchAll(new TypeRef<List<RouteRule>>() {});
        System.out.println("  rules via token: " + viaToken.size());
        rulesMapped = rulesMapped && viaToken.equals(rules);

        System.out.println();
        System.out.println("--- symptom 2: the cache ---");
        RuleCache cache = new RuleCache();
        cache.put("acme", List.of(new RouteRule("/orders", 10, true)));
        cache.markPlaceholder("globex");
        for (RouteRule rule : cache.get("globex")) {
            System.out.println("  cached route " + rule.path());
        }
        System.out.println("  globex entry read back cleanly, size "
                + cache.get("globex").size());
        cacheSafe = cache.rejectsWrongKeyType("globex");

        System.out.println();
        System.out.println("routing rules mapped to RouteRule : " + rulesMapped);
        System.out.println("cache rejects pollution at write  : " + cacheSafe);
        System.out.println(rulesMapped && cacheSafe ? "PASS" : "FAIL");
    }
}