fix: support @Embedded.Empty and @Embedded.Nullable in annotation processor (#118)

The annotation processor only recognized the full @Embedded(onEmpty = ...) form.
This adds detection of the shorthand @Embedded.Empty and @Embedded.Nullable
annotations in both embedded field detection and prefix extraction.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: lpandzic

infobip-spring-data-jdbc-annotation-processor-common/src/main/java/com/infobip/spring/data/jdbc/annotation/processor/CustomExtendedTypeFactory.java

@@ -23,6 +23,7 @@
 import com.querydsl.codegen.QueryTypeFactory;
 import com.querydsl.codegen.TypeMappings;
 import com.querydsl.codegen.utils.model.TypeCategory;
+import org.springframework.data.relational.core.mapping.Embedded;
 import org.springframework.data.relational.core.mapping.Table;
 import org.springframework.util.StringUtils;
 
@@ -117,11 +118,29 @@ private String getEmbeddedPrefix(Element parentElement, Property property) {
                            .filter(element -> element.getKind().equals(ElementKind.FIELD))
                            .filter(element -> element.getSimpleName().toString().equals(property.getName()))
                            .findFirst()
-                           .map(element -> element.getAnnotation(org.springframework.data.relational.core.mapping.Embedded.class))
-                           .map(org.springframework.data.relational.core.mapping.Embedded::prefix)
+                           .map(CustomExtendedTypeFactory::extractEmbeddedPrefix)
                            .orElse("");
     }
 
+    private static String extractEmbeddedPrefix(Element element) {
+        var embedded = element.getAnnotation(Embedded.class);
+        if (Objects.nonNull(embedded)) {
+            return embedded.prefix();
+        }
+
+        var embeddedEmpty = element.getAnnotation(Embedded.Empty.class);
+        if (Objects.nonNull(embeddedEmpty)) {
+            return embeddedEmpty.prefix();
+        }
+
+        var embeddedNullable = element.getAnnotation(Embedded.Nullable.class);
+        if (Objects.nonNull(embeddedNullable)) {
+            return embeddedNullable.prefix();
+        }
+
+        return "";
+    }
+
     private Property createPrefixedProperty(Property parentProperty, Property embeddedProperty, String prefix) {
         var prefixedName = prefix.isEmpty() ? embeddedProperty.getName() :
                           prefix + StringUtils.capitalize(embeddedProperty.getName());

infobip-spring-data-jdbc-annotation-processor-common/src/main/java/com/infobip/spring/data/jdbc/annotation/processor/Embeddeds.java

@@ -2,10 +2,12 @@
 
 import javax.lang.model.element.Element;
 import javax.lang.model.util.ElementFilter;
+import java.lang.annotation.Annotation;
 import java.util.Objects;
 
 import com.querydsl.apt.Configuration;
 import com.querydsl.codegen.Property;
+import org.springframework.data.relational.core.mapping.Embedded;
 
 class Embeddeds {
 
@@ -24,8 +26,7 @@ static boolean isEmbedded(Configuration configuration,
                             .filter(enclosedElement -> enclosedElement.getSimpleName()
                                                                       .toString()
                                                                       .equals(property.getName()))
-                            .allMatch(enclosedElement -> Objects.nonNull(
-                                    enclosedElement.getAnnotation(embeddedAnnotation)));
+                            .allMatch(Embeddeds::hasEmbeddedAnnotation);
     }
 
     static boolean isEmbedded(Configuration configuration, Element element) {
@@ -36,6 +37,16 @@ static boolean isEmbedded(Configuration configuration, Element element) {
             return false;
         }
 
-        return Objects.nonNull(element.getAnnotation(embeddedAnnotation));
+        return hasEmbeddedAnnotation(element);
+    }
+
+    private static boolean hasEmbeddedAnnotation(Element element) {
+        return hasAnnotation(element, Embedded.class)
+               || hasAnnotation(element, Embedded.Empty.class)
+               || hasAnnotation(element, Embedded.Nullable.class);
+    }
+
+    private static boolean hasAnnotation(Element element, Class<? extends Annotation> annotationType) {
+        return Objects.nonNull(element.getAnnotation(annotationType));
     }
 }

infobip-spring-data-jdbc-annotation-processor/src/test/java/com/infobip/spring/data/jdbc/annotation/processor/EntityWithEmbeddedEmpty.java

@@ -0,0 +1,20 @@
+package com.infobip.spring.data.jdbc.annotation.processor;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.relational.core.mapping.Embedded;
+
+@Schema("foo")
+public class EntityWithEmbeddedEmpty {
+
+    @Id
+    private final Long id;
+
+    @Embedded.Empty
+    private final EmbeddedClass embeddedClass;
+
+    public EntityWithEmbeddedEmpty(Long id,
+                                   EmbeddedClass embeddedClass) {
+        this.id = id;
+        this.embeddedClass = embeddedClass;
+    }
+}

infobip-spring-data-jdbc-annotation-processor/src/test/java/com/infobip/spring/data/jdbc/annotation/processor/EntityWithEmbeddedNullable.java

@@ -0,0 +1,20 @@
+package com.infobip.spring.data.jdbc.annotation.processor;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.relational.core.mapping.Embedded;
+
+@Schema("foo")
+public class EntityWithEmbeddedNullable {
+
+    @Id
+    private final Long id;
+
+    @Embedded.Nullable
+    private final EmbeddedClass embeddedClass;
+
+    public EntityWithEmbeddedNullable(Long id,
+                                      EmbeddedClass embeddedClass) {
+        this.id = id;
+        this.embeddedClass = embeddedClass;
+    }
+}

infobip-spring-data-jdbc-annotation-processor/src/test/java/com/infobip/spring/data/jdbc/annotation/processor/SpringDataJdbcAnnotationProcessorTest.java

@@ -189,6 +189,32 @@ void shouldIgnoreMappedCollectionAnnotatedFields() {
        thenShouldGenerateSourceFile(actual, QEntityWithMappedCollection.class);
     }
 
+    @Test
+    void shouldGenerateEmbeddedEmptyQClass() {
+        // given
+        var givenSource = givenSource(EntityWithEmbeddedEmpty.class);
+
+        // when
+        var actual = whenCompile(givenSource);
+
+        // then
+        thenShouldGenerateSourceFile(actual, "QEntityWithEmbeddedEmpty");
+        thenShouldGenerateSourceFile(actual, "QEmbeddedClass");
+    }
+
+    @Test
+    void shouldGenerateEmbeddedNullableQClass() {
+        // given
+        var givenSource = givenSource(EntityWithEmbeddedNullable.class);
+
+        // when
+        var actual = whenCompile(givenSource);
+
+        // then
+        thenShouldGenerateSourceFile(actual, "QEntityWithEmbeddedNullable");
+        thenShouldGenerateSourceFile(actual, "QEmbeddedClass");
+    }
+
     @Test
     void shouldGenerateMatchWithPrefixedPlayers() {
         // given
@@ -203,10 +229,15 @@ void shouldGenerateMatchWithPrefixedPlayers() {
     }
 
     private void thenShouldGenerateSourceFile(Compilation actual, Class<?> typeClass) {
+        thenShouldGenerateSourceFile(actual, typeClass.getSimpleName());
+    }
+
+    private void thenShouldGenerateSourceFile(Compilation actual, String simpleClassName) {
+        var fullName = "com.infobip.spring.data.jdbc.annotation.processor." + simpleClassName;
         assertThat(actual).succeeded();
         assertThat(actual)
-                .generatedSourceFile(typeClass.getName())
-                .hasSourceEquivalentTo(JavaFileObjects.forResource("expected/" + typeClass.getSimpleName() + ".java"));
+                .generatedSourceFile(fullName)
+                .hasSourceEquivalentTo(JavaFileObjects.forResource("expected/" + simpleClassName + ".java"));
     }
 
     private JavaFileObject givenSource(Class<?> type) {

infobip-spring-data-jdbc-annotation-processor/src/test/resources/expected/QEntityWithEmbeddedEmpty.java

@@ -0,0 +1,61 @@
+package com.infobip.spring.data.jdbc.annotation.processor;
+
+import static com.querydsl.core.types.PathMetadataFactory.*;
+
+import com.querydsl.core.types.dsl.*;
+
+import com.querydsl.core.types.PathMetadata;
+import javax.annotation.processing.Generated;
+import com.querydsl.core.types.Path;
+
+import com.querydsl.sql.ColumnMetadata;
+import java.sql.Types;
+
+
+
+
+/**
+ * QEntityWithEmbeddedEmpty is a Querydsl query type for EntityWithEmbeddedEmpty
+ */
+@Generated("com.infobip.spring.data.jdbc.annotation.processor.CustomMetaDataSerializer")
+public class QEntityWithEmbeddedEmpty extends com.querydsl.sql.RelationalPathBase<EntityWithEmbeddedEmpty> {
+
+    private static final long serialVersionUID = -229043138;
+
+    public static final QEntityWithEmbeddedEmpty entityWithEmbeddedEmpty = new QEntityWithEmbeddedEmpty("EntityWithEmbeddedEmpty");
+
+    public final NumberPath<Long> id = createNumber("id", Long.class);
+
+    public final StringPath foo = createString("foo");
+
+    public QEntityWithEmbeddedEmpty(String variable) {
+        super(EntityWithEmbeddedEmpty.class, forVariable(variable), "foo", "EntityWithEmbeddedEmpty");
+        addMetadata();
+    }
+
+    public QEntityWithEmbeddedEmpty(String variable, String schema, String table) {
+        super(EntityWithEmbeddedEmpty.class, forVariable(variable), schema, table);
+        addMetadata();
+    }
+
+    public QEntityWithEmbeddedEmpty(String variable, String schema) {
+        super(EntityWithEmbeddedEmpty.class, forVariable(variable), schema, "EntityWithEmbeddedEmpty");
+        addMetadata();
+    }
+
+    public QEntityWithEmbeddedEmpty(Path<? extends EntityWithEmbeddedEmpty> path) {
+        super(path.getType(), path.getMetadata(), "foo", "EntityWithEmbeddedEmpty");
+        addMetadata();
+    }
+
+    public QEntityWithEmbeddedEmpty(PathMetadata metadata) {
+        super(EntityWithEmbeddedEmpty.class, metadata, "foo", "EntityWithEmbeddedEmpty");
+        addMetadata();
+    }
+
+    public void addMetadata() {
+        addMetadata(id, ColumnMetadata.named("Id").withIndex(0));
+        addMetadata(foo, ColumnMetadata.named("Foo").withIndex(1));
+    }
+
+}

infobip-spring-data-jdbc-annotation-processor/src/test/resources/expected/QEntityWithEmbeddedNullable.java

@@ -0,0 +1,61 @@
+package com.infobip.spring.data.jdbc.annotation.processor;
+
+import static com.querydsl.core.types.PathMetadataFactory.*;
+
+import com.querydsl.core.types.dsl.*;
+
+import com.querydsl.core.types.PathMetadata;
+import javax.annotation.processing.Generated;
+import com.querydsl.core.types.Path;
+
+import com.querydsl.sql.ColumnMetadata;
+import java.sql.Types;
+
+
+
+
+/**
+ * QEntityWithEmbeddedNullable is a Querydsl query type for EntityWithEmbeddedNullable
+ */
+@Generated("com.infobip.spring.data.jdbc.annotation.processor.CustomMetaDataSerializer")
+public class QEntityWithEmbeddedNullable extends com.querydsl.sql.RelationalPathBase<EntityWithEmbeddedNullable> {
+
+    private static final long serialVersionUID = -229043138;
+
+    public static final QEntityWithEmbeddedNullable entityWithEmbeddedNullable = new QEntityWithEmbeddedNullable("EntityWithEmbeddedNullable");
+
+    public final NumberPath<Long> id = createNumber("id", Long.class);
+
+    public final StringPath foo = createString("foo");
+
+    public QEntityWithEmbeddedNullable(String variable) {
+        super(EntityWithEmbeddedNullable.class, forVariable(variable), "foo", "EntityWithEmbeddedNullable");
+        addMetadata();
+    }
+
+    public QEntityWithEmbeddedNullable(String variable, String schema, String table) {
+        super(EntityWithEmbeddedNullable.class, forVariable(variable), schema, table);
+        addMetadata();
+    }
+
+    public QEntityWithEmbeddedNullable(String variable, String schema) {
+        super(EntityWithEmbeddedNullable.class, forVariable(variable), schema, "EntityWithEmbeddedNullable");
+        addMetadata();
+    }
+
+    public QEntityWithEmbeddedNullable(Path<? extends EntityWithEmbeddedNullable> path) {
+        super(path.getType(), path.getMetadata(), "foo", "EntityWithEmbeddedNullable");
+        addMetadata();
+    }
+
+    public QEntityWithEmbeddedNullable(PathMetadata metadata) {
+        super(EntityWithEmbeddedNullable.class, metadata, "foo", "EntityWithEmbeddedNullable");
+        addMetadata();
+    }
+
+    public void addMetadata() {
+        addMetadata(id, ColumnMetadata.named("Id").withIndex(0));
+        addMetadata(foo, ColumnMetadata.named("Foo").withIndex(1));
+    }
+
+}