tessl/maven-com-mysema-querydsl--querydsl-apt

APT-based source code generation tool for Querydsl that generates type-safe query classes from annotated Java entity classes.

—

Pending

Overview

Eval results

Files

Configuration System

Name: tessl/maven-com-mysema-querydsl--querydsl-apt
Author: tessl

Comprehensive configuration system for customizing annotation processing behavior, code generation options, and framework-specific settings. The configuration controls how entities are discovered, processed, and serialized into Q-class files.

Capabilities

Configuration Interface

Core configuration interface defining all customization options for annotation processing.

/**
 * Configuration interface for APT-based Querydsl code generation
 */
public interface Configuration {
    
    // Annotation handling
    Class<? extends Annotation> getEntityAnnotation();
    Class<? extends Annotation> getAlternativeEntityAnnotation();
    Set<Class<? extends Annotation>> getEntityAnnotations();
    Class<? extends Annotation> getEntitiesAnnotation();
    Class<? extends Annotation> getSuperTypeAnnotation();
    Class<? extends Annotation> getEmbeddableAnnotation();
    Class<? extends Annotation> getEmbeddedAnnotation();
    Class<? extends Annotation> getSkipAnnotation();
    
    // Property discovery configuration
    boolean isUseFields();
    boolean isUseGetters();
    boolean isUnknownAsEmbedded();
    VisitorConfig getConfig(TypeElement e, List<? extends Element> elements);
    
    // Validation methods
    boolean isValidField(VariableElement field);
    boolean isValidGetter(ExecutableElement getter);
    boolean isValidConstructor(ExecutableElement constructor);
    boolean isBlockedField(VariableElement field);
    boolean isBlockedGetter(ExecutableElement getter);
    
    // Type and naming configuration
    TypeMappings getTypeMappings();
    QueryTypeFactory getQueryTypeFactory();
    String getNamePrefix();
    String getNameSuffix();
    Function<EntityType, String> getVariableNameFunction();
    
    // Serialization configuration
    Serializer getEntitySerializer();
    Serializer getEmbeddableSerializer();
    Serializer getSupertypeSerializer();
    Serializer getDTOSerializer();
    SerializerConfig getSerializerConfig(EntityType entityType);
    
    // Exclusion/inclusion rules
    void addExcludedPackage(String packageName);
    void addExcludedClass(String className);
    boolean isExcludedPackage(String packageName);
    boolean isExcludedClass(String className);
    
    // Type inspection
    TypeMirror getRealType(ExecutableElement method);
    TypeMirror getRealType(VariableElement field);
    void inspect(Element element, Annotations annotations);
    
    // Processing modes
    boolean isStrictMode();
    Collection<String> getKeywords();
}

Default Configuration

Standard implementation of the Configuration interface with sensible defaults and extensive customization options.

/**
 * Default implementation of the Configuration interface
 */
public class DefaultConfiguration implements Configuration {
    
    /**
     * Primary constructor for creating configuration instance
     * @param roundEnv Processing environment for current round
     * @param options Processor options from build configuration
     * @param keywords Reserved keywords to avoid in generated code  
     * @param entitiesAnn Package-level entities annotation (nullable)
     * @param entityAnn Primary entity annotation class
     * @param superTypeAnn Supertype annotation class (nullable)
     * @param embeddableAnn Embeddable annotation class (nullable)  
     * @param embeddedAnn Embedded annotation class (nullable)
     * @param skipAnn Skip/transient annotation class (nullable)
     */
    public DefaultConfiguration(
        RoundEnvironment roundEnv,
        Map<String, String> options,
        Collection<String> keywords,
        Class<? extends Annotation> entitiesAnn,
        Class<? extends Annotation> entityAnn,
        Class<? extends Annotation> superTypeAnn,
        Class<? extends Annotation> embeddableAnn,
        Class<? extends Annotation> embeddedAnn,
        Class<? extends Annotation> skipAnn);
    
    // Naming configuration methods
    public void setNamePrefix(String namePrefix);
    public void setNameSuffix(String nameSuffix);
    public void setUseFields(boolean useFields);
    public void setUseGetters(boolean useGetters);
    public void setStrictMode(boolean strictMode);
    public void setUnknownAsEmbedded(boolean unknownAsEmbedded);
    
    // Alternative annotation support
    public void setAlternativeEntityAnnotation(Class<? extends Annotation> ann);
    
    // Custom type mappings
    public <T> void addCustomType(Class<T> type, Class<? extends Expression<T>> queryType);
}

Configuration Creation Example:

// JPA Configuration example
RoundEnvironment roundEnv = ...; // From processor
Map<String, String> options = ...; // From build configuration

Configuration config = new DefaultConfiguration(
    roundEnv,
    options,
    Collections.emptySet(), // keywords
    null, // entitiesAnn
    Entity.class, // entityAnn - javax.persistence.Entity
    MappedSuperclass.class, // superTypeAnn
    Embeddable.class, // embeddableAnn  
    Embedded.class, // embeddedAnn
    Transient.class  // skipAnn
);

// Customize naming
config.setNamePrefix(""); // Default empty
config.setNameSuffix("Q"); // Default "Q" 
config.setUseFields(true);
config.setUseGetters(true);

Framework-Specific Configurations

Specialized configuration classes for different persistence frameworks.

/**
 * JPA-specific configuration
 */
public class JPAConfiguration extends DefaultConfiguration {
    public JPAConfiguration(RoundEnvironment roundEnv, 
                           Map<String,String> options,
                           Class<? extends Annotation> entity,
                           Class<? extends Annotation> superType,
                           Class<? extends Annotation> embeddable,
                           Class<? extends Annotation> embedded,
                           Class<? extends Annotation> skip);
}

/**
 * Hibernate-specific configuration with enhanced type support
 */
public class HibernateConfiguration extends JPAConfiguration {
    public HibernateConfiguration(RoundEnvironment roundEnv, 
                                 Map<String,String> options,
                                 Class<? extends Annotation> entity,
                                 Class<? extends Annotation> superType,
                                 Class<? extends Annotation> embeddable,
                                 Class<? extends Annotation> embedded,
                                 Class<? extends Annotation> skip) throws ClassNotFoundException;
}

/**
 * JDO-specific configuration
 */  
public class JDOConfiguration extends DefaultConfiguration {
    public JDOConfiguration(RoundEnvironment roundEnv,
                           Map<String,String> options,
                           Class<? extends Annotation> entities,
                           Class<? extends Annotation> entity,
                           Class<? extends Annotation> superType,
                           Class<? extends Annotation> embeddable,
                           Class<? extends Annotation> embedded,
                           Class<? extends Annotation> skip);
}

Property Discovery Configuration

Controls how annotation processors discover and process entity properties from classes.

/**
 * Configuration for controlling property visitor behavior
 */
public class VisitorConfig {
    // Pre-defined visitor configurations
    public static final VisitorConfig ALL = new VisitorConfig(true, true);
    public static final VisitorConfig FIELDS_ONLY = new VisitorConfig(true, false);
    public static final VisitorConfig METHODS_ONLY = new VisitorConfig(false, true);
    public static final VisitorConfig NONE = new VisitorConfig(false, false);
    
    /**
     * Whether to visit and process field properties
     * @return true if fields should be processed
     */
    public boolean visitFieldProperties();
    
    /**
     * Whether to visit and process method properties (getters)
     * @return true if methods should be processed  
     */
    public boolean visitMethodProperties();
}

Property Discovery Rules:

Field Processing (visitFieldProperties() == true):

Process all non-static, non-transient fields
Skip fields marked with skip annotation (e.g., @Transient)
Include fields marked with @QueryType regardless of modifiers

Method Processing (visitMethodProperties() == true):

Process getter methods matching naming conventions:
- getPropertyName() for general properties
- isPropertyName() for boolean properties
Methods must have no parameters and appropriate return types
Skip methods marked with skip annotation
Include methods marked with @QueryType regardless of modifiers

Custom Type Mappings

Configure custom type mappings for domain-specific types or framework extensions.

/**
 * Type mappings configuration for custom type handling
 */
public interface TypeMappings {
    void register(Type type, Type queryType);
    Type getPathType(EntityType entityType, EntityType model, boolean forProperty);
}

/**
 * Query type factory for creating path types
 */
public interface QueryTypeFactory {
    Type create(EntityType model);
}

Custom Type Example:

// Add custom type mapping for spatial types
DefaultConfiguration config = new DefaultConfiguration(...);

// Map java.awt.Point to custom query expression type
config.addCustomType(java.awt.Point.class, PointExpression.class);

// Map custom domain types
config.addCustomType(Money.class, MoneyExpression.class);
config.addCustomType(EmailAddress.class, StringExpression.class);

Validation Configuration

Configure field and method validation rules for entity processing.

/**
 * Field validation - determines which fields are processed
 * @param field Field element to validate
 * @return true if field should be included in query type
 */
boolean isValidField(VariableElement field);

/**
 * Method validation - determines which methods are processed  
 * @param getter Method element to validate
 * @return true if method should be included in query type
 */
boolean isValidGetter(ExecutableElement getter);

/**
 * Constructor validation - for projection types
 * @param constructor Constructor element to validate
 * @return true if constructor is valid for projections
 */
boolean isValidConstructor(ExecutableElement constructor);

Default Validation Rules:

Valid Fields:

Non-static, non-transient fields
Fields not marked with skip annotation
Fields explicitly marked with @QueryType (overrides other rules)

Valid Getters:

Non-static methods with getter naming convention
Methods not marked with skip annotation
Methods explicitly marked with @QueryType (overrides other rules)

Valid Constructors (for projections):

Public constructors
Marked with @QueryProjection annotation
Have at least one parameter

Serializer Configuration

Configure how entity models are serialized into Java source code.

/**
 * Configuration for controlling code generation serialization  
 */
public interface SerializerConfig {
    boolean entityAccessors();
    boolean listAccessors();
    boolean mapAccessors(); 
    boolean createDefaultVariable();
    String javadocSuffix();
}

/**
 * Simple serializer configuration implementation
 */
public class SimpleSerializerConfig implements SerializerConfig {
    public SimpleSerializerConfig(boolean entityAccessors,
                                 boolean listAccessors,
                                 boolean mapAccessors,
                                 boolean createDefaultVariable,
                                 String javadocSuffix);
    
    public static SerializerConfig getConfig(Config annotation);
}

Serialization Options:

Entity Accessors: Generate accessor methods for entity references
List Accessors: Generate specialized methods for list properties
Map Accessors: Generate specialized methods for map properties
Default Variable: Create static default instance (e.g., QUser.user)
Javadoc Suffix: Custom suffix for generated Javadoc comments

Install with Tessl CLI

npx tessl i tessl/maven-com-mysema-querydsl--querydsl-apt

docs

configuration.md

core-processing.md

framework-processors.md

index.md

processing-options.md

tile.json