ACC-2100 refactor PropertyNotFoundException, IllegalMediaTypeException and UnsupportedMediaTypeException

Let them extend ResponseStatusException and UnsupportedMediaTypeStatusException from spring web mvc. So that they will automatically be converted to problem details

Author: NielsCW

contentgrid-appserver-rest/src/main/java/com/contentgrid/appserver/rest/converter/AbstractHttpServletRequestConverter.java

@@ -1,24 +1,52 @@
 package com.contentgrid.appserver.rest.converter;
 
 import jakarta.servlet.http.HttpServletRequest;
+import java.io.IOException;
+import java.util.List;
 import java.util.Optional;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.MediaType;
 
-public interface HttpServletRequestConverter<T> {
+@Getter
+@RequiredArgsConstructor
+public abstract class HttpServletRequestConverter<T> {
+
+    private final List<MediaType> supportedMediaTypes;
+
+    HttpServletRequestConverter(MediaType... supportedMediaTypes) {
+        this(List.of(supportedMediaTypes));
+    }
 
     /**
-     * Returns whether this converter is able to convert the given request.
-     * Note: the body InputStream can not yet be consumed.
+     * Returns whether this converter is able to convert the given media type of the request.
      *
-     * @param request the request to check
-     * @return whether this converter is able to convert the given request
+     * @param mediaType the media type of the request to check
+     * @return whether this converter is able to convert the given media type of the request
      */
-    boolean canRead(HttpServletRequest request);
+    public boolean canRead(MediaType mediaType) {
+        return supportedMediaTypes.stream().anyMatch(supportedMediaType -> supportedMediaType.includes(mediaType));
+    }
 
     /**
      * Converts a {@link HttpServletRequest} and returns an {@link Optional} containing the converted request.
      *
      * @param request the request to be converted
      * @return an {@link Optional} containing the converted request, empty if it could not be converted
      */
-    Optional<T> convert(HttpServletRequest request);
+    public Optional<T> convert(HttpServletRequest request) {
+        try {
+            return Optional.ofNullable(read(request));
+        } catch (IOException e) {
+            return Optional.empty();
+        }
+    }
+
+    /**
+     * Converts a {@link HttpServletRequest}.
+     *
+     * @param request the request to be converted
+     * @return the converted request
+     */
+    protected abstract T read(HttpServletRequest request) throws IOException;
 }

contentgrid-appserver-rest/src/main/java/com/contentgrid/appserver/rest/converter/HttpServletRequestConverter.java

@@ -11,7 +11,7 @@
 import org.springframework.stereotype.Component;
 
 @Component
-public class UriListHttpServletRequestConverter extends AbstractHttpServletRequestConverter<List<URI>> {
+public class UriListHttpServletRequestConverter extends HttpServletRequestConverter<List<URI>> {
 
     public UriListHttpServletRequestConverter() {
         super(MediaType.parseMediaType("text/uri-list"));

contentgrid-appserver-rest/src/main/java/com/contentgrid/appserver/rest/converter/UriListHttpServletRequestConverter.java

@@ -0,0 +1,13 @@
+package com.contentgrid.appserver.rest.exception;
+
+import java.util.List;
+import org.springframework.http.MediaType;
+import org.springframework.web.server.UnsupportedMediaTypeStatusException;
+
+public class IllegalMediaTypeException extends UnsupportedMediaTypeStatusException {
+
+    public IllegalMediaTypeException(String mediaType, List<MediaType> supportedMediaTypes) {
+        super("Media type %s could not be parsed".formatted(mediaType), supportedMediaTypes);
+    }
+
+}

contentgrid-appserver-rest/src/main/java/com/contentgrid/appserver/rest/exception/IllegalMediaTypeException.java

@@ -1,11 +1,14 @@
 package com.contentgrid.appserver.rest.exception;
 
 import com.contentgrid.appserver.application.model.values.PathSegmentName;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.server.ResponseStatusException;
 
-public class PropertyNotFoundException extends RuntimeException {
+public class PropertyNotFoundException extends ResponseStatusException {
 
     public PropertyNotFoundException(PathSegmentName name) {
-        super("Property path with name '%s' not found".formatted(name));
+        super(HttpStatus.NOT_FOUND, "Property path with name '%s' not found".formatted(name));
+        getBody().setProperty("property", name.getValue());
     }
 
 }

contentgrid-appserver-rest/src/main/java/com/contentgrid/appserver/rest/exception/PropertyNotFoundException.java

@@ -1,9 +1,13 @@
 package com.contentgrid.appserver.rest.exception;
 
-public class UnsupportedMediaTypeException extends RuntimeException {
+import java.util.List;
+import org.springframework.http.MediaType;
+import org.springframework.web.server.UnsupportedMediaTypeStatusException;
 
-    public UnsupportedMediaTypeException(String mediaType) {
-        super("Media type %s not supported".formatted(mediaType));
+public class UnsupportedMediaTypeException extends UnsupportedMediaTypeStatusException {
+
+    public UnsupportedMediaTypeException(MediaType mediaType, List<MediaType> supportedMediaTypes) {
+        super(mediaType, supportedMediaTypes);
     }
 
 }

contentgrid-appserver-rest/src/main/java/com/contentgrid/appserver/rest/exception/UnsupportedMediaTypeException.java

@@ -26,27 +26,22 @@ public static <T extends PropertyRequestHandler> ResponseEntity<Object> handlePr
         var entity = application.getEntityByPathSegment(entityName)
                 .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Entity %s does not exist".formatted(entityName)));
 
-        var propertyExists = false;
-        Throwable cause = null;
+        UnsupportedMediaTypeException unsupportedMediaTypeException = null;
 
         for (var requestHandler : requestHandlers) {
             try {
                 return function.apply(requestHandler, entity);
             } catch (PropertyNotFoundException e) {
-                if (cause == null) {
-                    cause = e;
-                }
+                // skip
             } catch (UnsupportedMediaTypeException e) {
-                propertyExists = true;
-                cause = e;
+                unsupportedMediaTypeException = e;
             }
         }
 
-        if (propertyExists) {
-            throw new ResponseStatusException(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "Unsupported media type", cause);
+        if (unsupportedMediaTypeException != null) {
+            throw unsupportedMediaTypeException;
         } else {
-            throw new ResponseStatusException(HttpStatus.NOT_FOUND,
-                    "Property %s does not exist on entity %s".formatted(propertyName, entityName), cause);
+            throw new PropertyNotFoundException(propertyName);
         }
     }
 }

contentgrid-appserver-rest/src/main/java/com/contentgrid/appserver/rest/property/PropertyUtils.java

@@ -5,6 +5,7 @@
 import com.contentgrid.appserver.application.model.values.PathSegmentName;
 import com.contentgrid.appserver.query.engine.api.data.EntityId;
 import com.contentgrid.appserver.rest.converter.HttpServletRequestConverter;
+import com.contentgrid.appserver.rest.exception.IllegalMediaTypeException;
 import com.contentgrid.appserver.rest.exception.UnsupportedMediaTypeException;
 import com.contentgrid.appserver.rest.exception.PropertyNotFoundException;
 import jakarta.servlet.http.HttpServletRequest;
@@ -14,7 +15,10 @@
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.HttpStatus;
+import org.springframework.http.InvalidMediaTypeException;
+import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
+import org.springframework.util.InvalidMimeTypeException;
 import org.springframework.web.server.ResponseStatusException;
 
 @RequiredArgsConstructor
@@ -68,14 +72,25 @@ public final ResponseEntity<Object> deleteProperty(Application application, Enti
                 .orElseThrow(() -> new PropertyNotFoundException(propertyName));
     }
 
-    protected final ResponseEntity<Object> handleProperty(HttpServletRequest request, Function<T, ResponseEntity<Object>> function) throws UnsupportedMediaTypeException {
-        if (!requestConverter.canRead(request)) {
-            throw new UnsupportedMediaTypeException(request.getContentType());
-        }
+    protected final ResponseEntity<Object> handleProperty(HttpServletRequest request, Function<T, ResponseEntity<Object>> function)
+            throws IllegalMediaTypeException, UnsupportedMediaTypeException {
+        assertMediaTypeSupported(request);
         return requestConverter.convert(request).map(function)
                 .orElseThrow(() -> new ResponseStatusException(HttpStatus.BAD_REQUEST, "Invalid body"));
     }
 
+    private void assertMediaTypeSupported(HttpServletRequest request)
+            throws IllegalMediaTypeException, UnsupportedMediaTypeException {
+        try {
+            var mediaType = MediaType.parseMediaType(request.getContentType());
+            if (!requestConverter.canRead(mediaType)) {
+                throw new UnsupportedMediaTypeException(mediaType, requestConverter.getSupportedMediaTypes());
+            }
+        } catch (InvalidMediaTypeException | InvalidMimeTypeException e) {
+            throw new IllegalMediaTypeException(request.getContentType(), requestConverter.getSupportedMediaTypes());
+        }
+    }
+
     protected abstract ResponseEntity<Object> getProperty(Application application, Entity entity, EntityId instanceId, P property);
 
     protected abstract ResponseEntity<Object> postProperty(Application application, Entity entity, EntityId instanceId, P property, T body);