Hacking.

Author: mp911de

src/main/java/org/springframework/data/mapping/ComposedPropertyPath.java

@@ -45,8 +45,7 @@ public interface PropertyPath extends Streamable<PropertyPath> {
 	 * @since xxx
 	 */
 	public static <T, R> TypedPropertyPath<T, R> of(TypedPropertyPath<T, R> propertyPath) {
-		PropertyPathExtractor.getPropertyPathInformation(propertyPath);
-		return propertyPath;
+		return TypedPropertyPath.of(propertyPath);
 	}
 
 	/**

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

@@ -20,30 +20,89 @@
 import java.util.Iterator;
 
 import org.jspecify.annotations.Nullable;
-
 import org.springframework.data.util.TypeInformation;
 
 /**
+ * Type-safe representation of a property path expressed through method references.
+ * <p>
+ * This functional interface extends {@link PropertyPath} to provide compile-time type safety when declaring property
+ * paths. Instead of using {@link PropertyPath#from(String, TypeInformation) string-based property paths} that represent
+ * references to properties textually and that are prone to refactoring issues, {@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:
+ * 
+ * <pre class="code">
+ * PropertyPath.of(Person::getName);
+ * </pre>
+ * 
+ * Property paths can be composed to navigate nested properties using {@link #then(TypedPropertyPath)}:
+ * 
+ * <pre class="code">
+ * PropertyPath.of(Person::getAddress).then(Address::getCountry).then(Country::getName);
+ * </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.
+ * <p>
+ * As a functional interface, {@code TypedPropertyPath} should be implemented as method reference (recommended).
+ * Alternatively, the interface can be implemented as lambda extracting a property value from an object of type
+ * {@code T}. Implementations must ensure that the method reference or lambda correctly represents a property access
+ * through a method invocation or by field access. Arbitrary calls to non-getter methods (i.e. methods accepting
+ * parameters or arbitrary method calls on types other than the owning type are not allowed and will fail with
+ * {@link org.springframework.dao.InvalidDataAccessApiUsageException}.
+ * <p>
+ * Note that using lambda expressions requires bytecode analysis of the declaration site classes and therefore presence
+ * of their class files.
+ * 
+ * @param <T> the owning type of the property path segment, but typically the root type for composed property paths.
+ * @param <P> the property value type at this path segment.
  * @author Mark Paluch
+ * @see PropertyPath
+ * @see #of(TypedPropertyPath)
+ * @see #then(TypedPropertyPath)
  */
 @FunctionalInterface
-public interface TypedPropertyPath<T, R> extends Serializable, PropertyPath {
+public interface TypedPropertyPath<T, P> extends PropertyPath, Serializable {
 
-	R get(T obj);
+	/**
+	 * Syntax sugar to create a {@link TypedPropertyPath} from a method reference or lambda.
+	 * <p>
+	 * This method returns a resolved {@link TypedPropertyPath} by introspecting the given lambda.
+	 *
+	 * @param lambda the method reference or lambda.
+	 * @param <T> owning type.
+	 * @param <P> property type.
+	 * @return the typed property path.
+	 */
+	static <T, P> TypedPropertyPath<T, P> of(TypedPropertyPath<T, P> lambda) {
+		return TypedPropertyPaths.of(lambda);
+	}
+
+	/**
+	 * Get the property value for the given object.
+	 *
+	 * @param obj the object to get the property value from.
+	 * @return the property value.
+	 */
+	@Nullable
+	P get(T obj);
 
 	@Override
 	default TypeInformation<?> getOwningType() {
-		return PropertyPathExtractor.getPropertyPathInformation(this).owner();
+		return TypedPropertyPaths.getPropertyPathInformation(this).owner();
 	}
 
 	@Override
 	default String getSegment() {
-		return PropertyPathExtractor.getPropertyPathInformation(this).property().getName();
+		return TypedPropertyPaths.getPropertyPathInformation(this).property().getName();
 	}
 
 	@Override
 	default TypeInformation<?> getTypeInformation() {
-		return PropertyPathExtractor.getPropertyPathInformation(this).propertyType();
+		return TypedPropertyPaths.getPropertyPathInformation(this).propertyType();
 	}
 
 	@Override
@@ -62,8 +121,14 @@ default Iterator<PropertyPath> iterator() {
 		return Collections.singletonList((PropertyPath) this).iterator();
 	}
 
-	default <N> TypedPropertyPath<T, N> then(TypedPropertyPath<R, N> next) {
-		return new ComposedPropertyPath<>(this, 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 accepting a property path owned by the {@code P} type.
+	 * @param <N> the new property value type.
+	 * @return a new composed {@code TypedPropertyPath}.
+	 */
+	default <N> TypedPropertyPath<T, N> then(TypedPropertyPath<P, N> next) {
+		return TypedPropertyPaths.compose(this, of(next));
 	}
-
 }