Fix delete method matching

Author: radovanradic

.github/workflows/graalvm-latest.yml

@@ -9,6 +9,7 @@ on:
     branches:
       - master
       - '[0-9]+.[0-9]+.x'
+      - fix-delete-matcher
   pull_request:
     branches:
       - master

.github/workflows/gradle.yml

@@ -9,6 +9,7 @@ on:
     branches:
       - master
       - '[0-9]+.[0-9]+.x'
+      - fix-delete-matcher
   pull_request:
     branches:
       - master

data-processor/src/main/java/io/micronaut/data/processor/visitors/finders/TypeUtils.java

@@ -137,35 +137,52 @@ public static boolean isEntity(@Nullable ClassElement type) {
     }
 
     /**
-     * Does the given type have an {@link MappedEntity} and is of given type.
-     * @param type The type
-     * @param entityType The type to check equality with
-     * @return True if it does
+     * Checks if the given type is an entity of the specified type.
+     *
+     * A type is considered an entity if it is annotated with {@link MappedEntity} and is not an array.
+     * The type is considered to be of the given entity type if its name matches or if it is assignable to the given entity type.
+     *
+     * @param type The type to check. May be null.
+     * @param entityType The expected entity type. Must not be null.
+     * @return true if the type is an entity of the given type, false otherwise.
      */
     public static boolean isEntityOfType(@Nullable ClassElement type, @NonNull ClassElement entityType) {
         if (type == null) {
             return false;
         }
-        if (!isEntity(type)) {
+        if (type.isArray() || !type.hasStereotype(MappedEntity.class)) {
             return false;
         }
         // Ensure the entity matches the expected type
         String expected = entityType.getName();
         return type.getName().equals(expected) || type.isAssignable(expected);
     }
 
+    /**
+     * Checks if the given type is an iterable (or array) of entities of the specified type.
+     *
+     * A type is considered an iterable of entities if it is an array or implements {@link Iterable} and its element type
+     * is an entity of the given type.
+     *
+     * @param type The type to check. May be null.
+     * @param entityType The expected entity type. Must not be null.
+     * @return true if the type is an iterable of entities of the given type, false otherwise.
+     */
     public static boolean isIterableOfEntityType(@Nullable ClassElement type, @NonNull ClassElement entityType) {
         if (type == null) {
             return false;
         }
-        if (!isIterableOfEntity(type)) {
-            return false;
+        ClassElement actualElementType = null;
+        if (type.isArray() && isEntity(type.fromArray())) {
+            actualElementType = type.fromArray();
+        }
+        if (actualElementType == null) {
+            actualElementType = type.getFirstTypeArgument().orElse(null);
         }
-        ClassElement elementType = type.getFirstTypeArgument().orElse(null);
-        if (elementType == null) {
+        if (actualElementType == null) {
             return false;
         }
-        return isEntityOfType(elementType, entityType);
+        return isEntityOfType(actualElementType, entityType);
     }
 
 //    /**

data-processor/src/test/groovy/io/micronaut/data/processor/sql/BuildDeleteSpec.groovy

@@ -121,33 +121,8 @@ interface BookRepository extends CrudRepository<Book, Long> {
     int deleteAllByIdAndAuthorId(Long id, Long authorId);
 
     int deleteAllByAuthor(Author author);
-
-    //void remove(Author author);
-
-    //void removeAll(List<Author> authors);
-
-    void deleteByAuthor(Author author);
-
 }
 """)
-        /*when:
-            def removeAuthorMethod = repository.findMethod("remove", Author).get()
-        then:
-            removeAuthorMethod
-            getDataInterceptor(removeAuthorMethod) == "io.micronaut.data.intercept.DeleteAllInterceptor"
-            getQuery(removeAuthorMethod) == "DELETE  FROM `book`  WHERE (`author_id` = ?)"
-        when:
-            def removeAllAuthorsMethod = repository.findPossibleMethods("removeAll").findFirst().get()
-        then:
-            removeAllAuthorsMethod
-            getDataInterceptor(removeAllAuthorsMethod) == "io.micronaut.data.intercept.DeleteAllInterceptor"
-            getQuery(removeAllAuthorsMethod) == "DELETE  FROM `book`  WHERE (`id` IN (?))"*/
-        when:
-            def deleteByAuthorMethod = repository.findMethod("deleteByAuthor", Author).get()
-        then:
-            deleteByAuthorMethod
-            getDataInterceptor(deleteByAuthorMethod) == "io.micronaut.data.intercept.DeleteAllInterceptor"
-            getQuery(deleteByAuthorMethod) == "DELETE  FROM `book`  WHERE (`author_id` = ?)"
         when:
             def deleteByIdAndAuthorIdMethod = repository.findPossibleMethods("deleteByIdAndAuthorId").findFirst().get()
         then:
@@ -219,6 +194,77 @@ interface BookRepository extends GenericRepository<Book, Long> {
         e.message.contains('Cannot delete entities of type: author')
     }
 
+    void "test build delete with embedded id"() {
+        given:
+        def repository = buildRepository('test.CustomerRepository', """
+import io.micronaut.data.annotation.Embeddable;
+import io.micronaut.data.annotation.EmbeddedId;
+import io.micronaut.data.annotation.MappedEntity;
+import io.micronaut.data.jdbc.annotation.JdbcRepository;
+import io.micronaut.data.model.query.builder.sql.Dialect;
+
+@MappedEntity
+class Customer {
+    @EmbeddedId
+    private CustomerId customerId;
+    private String fullName;
+    private String email;
+    public CustomerId getCustomerId() {
+        return customerId;
+    }
+    public void setCustomerId(CustomerId customerId) {
+        this.customerId = customerId;
+    }
+    public String getFullName() {
+        return fullName;
+    }
+    public void setFullName(String fullName) {
+        this.fullName = fullName;
+    }
+    public String getEmail() {
+        return email;
+    }
+    public void setEmail(String email) {
+        this.email = email;
+    }
+}
+
+@Embeddable
+@MappedEntity // To test deleteById matching
+class CustomerId  {
+    private String regionCode;
+    private String tenantId;
+    public String getRegionCode() {
+        return regionCode;
+    }
+    public void setRegionCode(String regionCode) {
+        this.regionCode = regionCode;
+    }
+    public String getTenantId() {
+        return tenantId;
+    }
+    public void setTenantId(String tenantId) {
+        this.tenantId = tenantId;
+    }
+}
+
+@JdbcRepository(dialect = Dialect.H2)
+interface CustomerRepository extends CrudRepository<Customer, CustomerId> {
+    int deleteAllByCustomerIdRegionCode(String regionCode);
+}
+""")
+        when:
+        def deleteAllByCustomerIdRegionCodeMethod = repository.findPossibleMethods("deleteAllByCustomerIdRegionCode").findFirst().get()
+        then:
+        getQuery(deleteAllByCustomerIdRegionCodeMethod) == 'DELETE  FROM `customer`  WHERE (`customer_id_region_code` = ?)'
+        getDataInterceptor(deleteAllByCustomerIdRegionCodeMethod) == "io.micronaut.data.intercept.DeleteAllInterceptor"
+        when:
+        def deleteByIdMethod = repository.findPossibleMethods("deleteById").findFirst().get()
+        then:
+        getQuery(deleteByIdMethod) == 'DELETE  FROM `customer`  WHERE (`customer_id_region_code` = ? AND `customer_id_tenant_id` = ?)'
+        getDataInterceptor(deleteByIdMethod) == "io.micronaut.data.intercept.DeleteAllInterceptor"
+    }
+
     void  "test build delete query with DataTransformer"() {
         given:
         def repository = buildRepository('test.UuidEntityRepository', """