Type safe way to go from a String to a Strategy with Jackson

I want to execute queries with filters, from UI, based on logical operators (>20).

Currently, the logical operator (matcher) is a constant that Jackson maps to an enum.
Then I have a large pattern-matching switch that then maps each enum to a function.
A function that generates a predicate using the Hibernate Criteria Builder.
This is generally a pragmatic simple solution - but the long switch statement eventually will become unmanageable.

A map lookup is no better because you would have to configure the map as big block of text first, which in essence is no different from a large pattern matching switch.

So I am looking for a type-safe way to go from a string in a json file to the concrete
implementing strategy, e.g from "TEXT_EQUALS_ to a TextEqualsMatcher that can build a Hibernate Predicate with a CriteriaBuilder method parameter.

Yes, this would strongly couple json to Hibernate -
but I think the coupling is there anyway, one way or another because we have database filters - and IMHO the advantages of a very lean implementation without any lookup could justify it

So basically I am looking for a type-safe way to go from this:

{
  "type": "field",
  "id": "104e578c-6841-48e5-8ee0-927a1eaa0fbe",
  "value": "Ukraine",
  "matcher": "text_equals"
}

to this:

public class TextEqualsMatcher implements FieldMatcher {
    @Override
    public Predicate toPredicate(CriteriaBuilder cb, Path<String> path) {
        // Logic to build and return the predicate for the Text Equals condition
    }
}

The code would probably be something like this:
public interface Filter {
    Predicate toPredicate(CriteriaBuilder cb, Path<String> path);
}

@JsonTypeName("field")
public record FieldElement(
        @JsonProperty("id") UUID id,
        @JsonProperty("value") String value,
        @JsonProperty("matcher") FieldMatcher matcher
) implements Filter {
    public Predicate toPredicate(CriteriaBuilder cb, Path<String> path) {
        return matcher.toPredicate(cb, path, value);
    }
}

public interface FieldMatcher {
    Predicate toPredicate(CriteriaBuilder cb, Path<String> path, String value);
}

@JsonTypeName("text_equals")
public class TextEqualsMatcher implements FieldMatcher {
    public Predicate toPredicate(CriteriaBuilder cb, Path<String> path, String value) {
        // Logic to build and return the predicate for the Text Equals condition
    }
}

So a @JsonTypeName with an Enum constant would be great I guess:

@JsonTypeName(MatcherType.TEXT_EQUALS)

Any input/ideas?

It seems doable: you do need to add @JsonTypeInfo in base interfaces (to indicate polymorphic handling), and also @JsonSubTypes references from base- to sub-types (which is bit unfortunate).
But with that it seems things should work?