Collection support.

Author: mp911de

src/main/java/org/springframework/data/core/PropertyPath.java

@@ -19,7 +19,6 @@
 import java.util.regex.Pattern;
 
 import org.jspecify.annotations.Nullable;
-
 import org.springframework.data.util.Streamable;
 import org.springframework.util.Assert;
 
@@ -43,11 +42,27 @@ public interface PropertyPath extends Streamable<PropertyPath> {
 	 * @param <T> owning type.
 	 * @param <P> property type.
 	 * @return the typed property path.
+	 * @since 4.1
 	 */
 	static <T, P> TypedPropertyPath<T, P> of(TypedPropertyPath<T, P> propertyPath) {
 		return TypedPropertyPaths.of(propertyPath);
 	}
 
+	/**
+	 * Syntax sugar to create a {@link TypedPropertyPath} from a method reference or lambda for a collection property.
+	 * <p>
+	 * This method returns a resolved {@link TypedPropertyPath} by introspecting the given method reference or lambda.
+	 *
+	 * @param propertyPath the method reference or lambda.
+	 * @param <T> owning type.
+	 * @param <P> property type.
+	 * @return the typed property path.
+	 * @since 4.1
+	 */
+	static <T, P> TypedPropertyPath<T, P> ofMany(TypedPropertyPath<T, ? extends Iterable<P>> propertyPath) {
+		return (TypedPropertyPath) TypedPropertyPaths.of(propertyPath);
+	}
+
 	/**
 	 * Returns the owning type of the {@link PropertyPath}.
 	 *

src/main/java/org/springframework/data/core/TypedPropertyPath.java

@@ -22,38 +22,41 @@
 import org.jspecify.annotations.Nullable;
 
 /**
- * Type-safe representation of a property path using getter method references or lambda expressions.
+ * Interface providing type-safe property path navigation through method references or lambda expressions.
  * <p>
  * This functional interface extends {@link PropertyPath} to provide compile-time type safety and refactoring support.
  * Instead of using {@link PropertyPath#from(String, TypeInformation) string-based property paths} for textual property
  * representation that are easy to miss when changing the domain model, {@code TypedPropertyPath} leverages Java's
  * declarative method references and lambda expressions to ensure type-safe property access.
  * <p>
- * Typed property paths can be created directly they are accepted used or conveniently using the static factory method
- * {@link #of(TypedPropertyPath)} with method references:
+ * Create a typed property path using the static factory method {@link #of(TypedPropertyPath)} with a method reference
+ * or lambda, for example:
  *
  * <pre class="code">
- * PropertyPath.of(Person::getName);
+ * TypedPropertyPath&lt;Person, String&gt; name = TypedPropertyPath.of(Person::getName);
  * </pre>
- *
- * Property paths can be composed to navigate nested properties using {@link #then(TypedPropertyPath)}:
+ * 
+ * The resulting object can be used to obtain the {@link #toDotPath() dot-path} and to interact with the targetting
+ * property. Typed paths allow for composition to navigate nested object structures using
+ * {@link #then(TypedPropertyPath)}:
  *
  * <pre class="code">
- * PropertyPath.of(Person::getAddress).then(Address::getCity);
+ * TypedPropertyPath&lt;Person, String&gt; city = TypedPropertyPath.of(Person::getAddress).then(Address::getCity);
  * </pre>
  * <p>
- * The interface maintains type information throughout the property path chain: the {@code T} type parameter represents
- * its owning type (root type for composed paths), while {@code P} represents the property value type at this path
- * segment.
+ * The generic type parameters preserve type information across the property path chain: {@code T} represents the owning
+ * type of the current segment (or the root type for composed paths), while {@code P} represents the property value type
+ * at this segment. Composition automatically flows type information forward, ensuring that {@code then()} preserves the
+ * full chain's type safety.
  * <p>
- * Use method references (recommended) or lambdas that access a property getter to implement {@code TypedPropertyPath}.
- * Usage of constructor references, method calls with parameters, and complex expressions results in
- * {@link org.springframework.dao.InvalidDataAccessApiUsageException}. In contrast to method references, introspection
- * of lambda expressions requires bytecode analysis of the declaration site classes and therefore presence of their
- * class files.
+ * Implement {@code TypedPropertyPath} using method references (strongly recommended) or lambdas that directly access a
+ * property getter. Constructor references, method calls with parameters, and complex expressions are not supported and
+ * result in {@link org.springframework.dao.InvalidDataAccessApiUsageException}. Unlike method references, introspection
+ * of lambda expressions requires bytecode analysis of the declaration site classes and thus depends on their
+ * availability at runtime.
  *
- * @param <T> the owning type of the property path segment, root type for composed paths.
- * @param <P> the property type at this path segment.
+ * @param <T> the owning type of this path segment; the root type for composed paths.
+ * @param <P> the property value type at this path segment.
  * @author Mark Paluch
  * @since 4.1
  * @see PropertyPath#of(TypedPropertyPath)
@@ -76,6 +79,21 @@ public interface TypedPropertyPath<T, P> extends PropertyPath, Serializable {
 		return TypedPropertyPaths.of(propertyPath);
 	}
 
+	/**
+	 * Syntax sugar to create a {@link TypedPropertyPath} from a method reference or lambda for a collection property.
+	 * <p>
+	 * This method returns a resolved {@link TypedPropertyPath} by introspecting the given method reference or lambda.
+	 *
+	 * @param propertyPath the method reference or lambda.
+	 * @param <T> owning type.
+	 * @param <P> property type.
+	 * @return the typed property path.
+	 * @since 4.1
+	 */
+	static <T, P> TypedPropertyPath<T, P> ofMany(TypedPropertyPath<T, ? extends Iterable<P>> propertyPath) {
+		return (TypedPropertyPath) TypedPropertyPaths.of(propertyPath);
+	}
+
 	/**
 	 * Get the property value for the given object.
 	 *
@@ -128,4 +146,17 @@ default Iterator<PropertyPath> iterator() {
 		return TypedPropertyPaths.compose(this, of(next));
 	}
 
+	/**
+	 * Extend the property path by appending the {@code next} path segment and returning a new property path instance.
+	 *
+	 * @param next the next property path segment as method reference or lambda accepting the owner object {@code P} type
+	 *          and returning {@code N} as result of accessing a property.
+	 * @param <N> the new property value type.
+	 * @return a new composed {@code TypedPropertyPath}.
+	 */
+	default <N extends @Nullable Object> TypedPropertyPath<T, N> thenMany(
+			TypedPropertyPath<P, ? extends Iterable<N>> next) {
+		return (TypedPropertyPath) TypedPropertyPaths.compose(this, of(next));
+	}
+
 }

src/main/kotlin/org/springframework/data/core/TypedPropertyPathExtensions.kt

@@ -66,6 +66,14 @@ class KTypedPropertyPath {
 			return of((property as KProperty<P?>))
 		}
 
+		/**
+		 * Create a [TypedPropertyPath] from a collection-like [KProperty1].
+		 */
+		@JvmName("ofMany")
+		fun <T : Any, P : Any> of(property: KProperty1<T, Iterable<P>>): TypedPropertyPath<T, P> {
+			return of((property as KProperty<P?>))
+		}
+
 		/**
 		 * Create a [TypedPropertyPath] from a [KProperty].
 		 */

src/test/java/org/springframework/data/core/TypedPropertyPathUnitTests.java

@@ -17,6 +17,8 @@
 
 import static org.assertj.core.api.Assertions.*;
 
+import java.util.List;
+
 import org.jspecify.annotations.Nullable;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -63,6 +65,12 @@ void resolvesMHComposedPath() {
 				.isEqualTo("address.country");
 	}
 
+	@Test
+	void resolvesCollectionPath() {
+		assertThat(PropertyPath.ofMany(PersonQuery::getAddresses).then(Address::getCity).toDotPath())
+				.isEqualTo("addresses.city");
+	}
+
 	@Test
 	void resolvesInitialLambdaGetter() {
 		assertThat(PropertyPath.of((PersonQuery person) -> person.getName()).toDotPath()).isEqualTo("name");
@@ -235,6 +243,7 @@ static public class PersonQuery extends SuperClass {
 		private String name;
 		private Integer age;
 		private Address address;
+		private List<Address> addresses;
 
 		public PersonQuery(PersonQuery pq) {}
 
@@ -252,6 +261,14 @@ public Integer getAge() {
 		public Address getAddress() {
 			return address;
 		}
+
+		public List<Address> getAddresses() {
+			return addresses;
+		}
+
+		public void setAddresses(List<Address> addresses) {
+			this.addresses = addresses;
+		}
 	}
 
 	class Address {

src/test/kotlin/org/springframework/data/core/KTypedPropertyPathUnitTests.kt

@@ -29,6 +29,14 @@ class KTypedPropertyPathUnitTests {
 		assertThat(path.toDotPath()).isEqualTo("author.name")
 	}
 
+	@Test
+	fun shouldComposeManyPropertyPath() {
+
+		val path = KTypedPropertyPath.of(Author::books).then(Book::title)
+
+		assertThat(path.toDotPath()).isEqualTo("books.title")
+	}
+
 	@Test
 	fun shouldCreateComposed() {