feat: validate dynamic entity attribute

- Add POST /api/{entity}/validate/{attributeName} endpoint (accept raw request body)
- Run configured attribute validators (no side effects)
- Expose validate route in /metadata/routes with disabledRoutes support
- Add i18n message for unknown attribute
- Refocus controller tests on delegation; add validateAttribute engine coverage
- Cleanup redundant override Javadoc

Author: christophechevalier

src/main/java/io/github/linagora/linid/im/controller/GenericController.java

@@ -190,4 +190,28 @@ public ResponseEntity<Void> deleteEntity(@PathVariable String entity, @PathVaria
 
     return ResponseEntity.noContent().build();
   }
+
+  /**
+   * Validates a single attribute value for a dynamic entity.
+   *
+   * <p>
+   * This endpoint performs validation only (no side-effects). When validation succeeds, HTTP 204 (No Content) is returned.
+   *
+   * @param entityRoute entity route (as used in configuration)
+   * @param attributeName attribute name to validate
+   * @param value request body value to validate; may be omitted, in which case the value is treated as {@code null} for
+   *     validation purposes
+   * @param request HTTP request
+   * @return 204 No Content on success; 404 if entity or attribute not found; 400 if validation fails
+   */
+  @PostMapping("/validate/{attributeName}")
+  public ResponseEntity<Void> validateAttribute(
+      @PathVariable("entity") String entityRoute,
+      @PathVariable("attributeName") String attributeName,
+      @RequestBody(required = false) Object value,
+      HttpServletRequest request) {
+    service.validateAttribute(entityRoute, attributeName, value);
+    return ResponseEntity.noContent().build();
+  }
+
 }

src/main/java/io/github/linagora/linid/im/plugin/config/PluginConfigurationServiceImpl.java

@@ -203,6 +203,7 @@ public List<RouteDescription> getRouteDescriptions() {
 
     final String defaultRoutePattern = "/api/%s";
     final String routeWithIdPattern = "/api/%s/{id}";
+    final String validateAttributePattern = "/api/%s/validate/{attributeName}";
 
     this.root.getEntities().forEach(entity -> {
       routeDescriptions.add(
@@ -247,6 +248,16 @@ public List<RouteDescription> getRouteDescriptions() {
                 List.of("id")
             ));
       }
+
+      if (!entity.getDisabledRoutes().contains("validate")) {
+        routeDescriptions.add(
+            new RouteDescription(
+                "POST",
+                String.format(validateAttributePattern, entity.getRoute()),
+                entity.getName(),
+                List.of("attributeName")
+            ));
+      }
     });
 
     this.routeRegistry.getPlugins().forEach(plugin -> routeDescriptions

src/main/java/io/github/linagora/linid/im/plugin/entity/DynamicEntityServiceImpl.java

@@ -322,4 +322,12 @@ public ProviderConfiguration   getProviderConfiguration(DynamicEntity entity) {
                 "provider", entity.getConfiguration().getProvider())
         )));
   }
+
+  @Override
+  public void validateAttribute(String entityName, String attributeName, Object value) {
+    var entity = new DynamicEntity();
+    updateEntityConfiguration(entity, entityName);
+
+    validationEngine.validateAttribute(entity, attributeName, value);
+  }
 }

src/main/java/io/github/linagora/linid/im/plugin/validation/ValidationEngineImpl.java

@@ -96,6 +96,45 @@ public void validate(DynamicEntity dynamicEntity, String phase) {
     }
   }
 
+  @Override
+  public void validateAttribute(DynamicEntity dynamicEntity, String attributeName, Object value) {
+    var attributeConfiguration = dynamicEntity.getConfiguration()
+        .getAttributes()
+        .stream()
+        .filter(attribute -> attributeName.equals(attribute.getName()))
+        .findFirst()
+        .orElseThrow(() -> new ApiException(
+            404,
+            I18nMessage.of(
+                "error.attribute.unknown",
+                Map.of(
+                    "entity", dynamicEntity.getConfiguration().getName(),
+                    "attribute", attributeName))));
+
+    List<I18nMessage> errors = new ArrayList<>();
+
+    attributeConfiguration.getValidations()
+        .stream()
+        .map(this::mergeConfigurationWithGlobal)
+        .forEach(configuration -> getValidationPlugin(configuration)
+            .validate(configuration, value)
+            .ifPresent(error -> {
+              error.context().put("entity", dynamicEntity.getConfiguration().getName());
+              error.context().put("attribute", attributeName);
+
+              errors.add(error);
+            }));
+
+    if (!errors.isEmpty()) {
+      throw new ApiException(
+          400,
+          I18nMessage.of(
+              "error.entity.attributes",
+              Map.of("entity", dynamicEntity.getConfiguration().getName())),
+          Map.of("errors", errors));
+    }
+  }
+
   /**
    * Resolves the correct {@link ValidationPlugin} for a given validation configuration.
    *

src/main/resources/i18n/en.json

@@ -1,6 +1,7 @@
 {
   "error.router.unknown.route": "Unknown route: {route}",
   "error.entity.unknown": "Unknown entity: {entity}",
+  "error.attribute.unknown": "Unknown attribute '{attribute}' for entity '{entity}'",
   "error.entity.attributes": "Validation errors occurred for entity: {entity}",
   "error.provider.unknown": "Unknown provider '{provider}' for entity '{entity}'",
   "error.plugin.unknown": "Unknown plugin: {type}"

src/main/resources/i18n/fr.json

@@ -1,6 +1,7 @@
 {
   "error.router.unknown.route": "Route inconnue: {route}",
   "error.entity.unknown": "Entité inconnue: {entity}",
+  "error.attribute.unknown": "Attribut inconnu '{attribute}' pour l'entité '{entity}'",
   "error.entity.attributes": "Erreurs de validation pour l'entité: {entity}",
   "error.provider.unknown": "Provider inconnu '{provider}' pour l'entité '{entity}'",
   "error.plugin.unknown": "Plugin inconnu: {type}"

src/test/java/io/github/linagora/linid/im/controller/GenericControllerTest.java

@@ -28,6 +28,10 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doNothing;
 
 import io.github.linagora.linid.im.corelib.plugin.entity.DynamicEntity;
 import io.github.linagora.linid.im.corelib.plugin.entity.DynamicEntityMapper;
@@ -168,4 +172,22 @@ void testDeleteEntity() {
     assertNotNull(response);
     assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode());
   }
+
+  @Test
+  @DisplayName("test validateAttribute: should return 204 when valid")
+  void testValidateAttributeWhenValid() {
+    var request = Mockito.mock(HttpServletRequest.class);
+    doNothing().when(service).validateAttribute(eq("users"), eq("email"), eq("a@b.com"));
+
+    ResponseEntity<Void> response = controller.validateAttribute(
+        "users",
+        "email",
+        "a@b.com",
+        request
+    );
+
+    assertNotNull(response);
+    assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode());
+    Mockito.verify(service).validateAttribute(eq("users"), eq("email"), eq("a@b.com"));
+  }
 }

src/test/java/io/github/linagora/linid/im/plugin/config/PluginConfigurationServiceImplTest.java

@@ -246,7 +246,7 @@ void shouldReturnExcludeDisabledRoutes() {
     EntityConfiguration entity = new EntityConfiguration();
     entity.setName("User");
     entity.setRoute("users");
-    entity.setDisabledRoutes(List.of("create", "update", "patch", "delete", "findById", "findAll"));
+    entity.setDisabledRoutes(List.of("create", "update", "patch", "delete", "findById", "findAll", "validate"));
 
     RootConfiguration root = new RootConfiguration();
     root.setEntities(List.of(entity));

src/test/java/io/github/linagora/linid/im/plugin/entity/DynamicEntityServiceImplTest.java

@@ -311,7 +311,10 @@ void testHandleFindAll() {
     service.handleFindAll(request, "test", MultiValueMap.fromMultiValue(Map.of()), null);
 
     Mockito.verify(authPlugin, Mockito.times(1)).validateToken(Mockito.any(), Mockito.any());
-    Mockito.verify(authPlugin, Mockito.times(1)).isAuthorized(Mockito.any(), Mockito.any(), Mockito.any(MultiValueMap.class),
+    Mockito.verify(authPlugin, Mockito.times(1)).isAuthorized(
+        Mockito.any(),
+        Mockito.any(),
+        Mockito.<MultiValueMap<String, String>>any(),
         Mockito.eq("READ"),
         Mockito.any());
     Mockito.verify(validationEngine, Mockito.times(1)).validate(Mockito.any(), Mockito.eq("beforeFindAll"));
@@ -380,4 +383,33 @@ void testGetProviderConfiguration() {
     assertEquals(Map.of("entity", "name", "provider", "provider"), ex.getError().context());
     assertEquals(500, ex.getStatusCode());
   }
+
+  @Test
+  @DisplayName("test validateAttribute: should load configuration and delegate to validation engine")
+  void testValidateAttributeShouldDelegate() {
+    var entityConfiguration = new EntityConfiguration();
+    entityConfiguration.setName("users");
+
+    Mockito.when(configurationService.getEntityConfiguration("users"))
+        .thenReturn(Optional.of(entityConfiguration));
+    Mockito.doNothing().when(validationEngine).validateAttribute(Mockito.any(), Mockito.any(), Mockito.any());
+
+    service.validateAttribute("users", "email", "a@b.com");
+
+    ArgumentCaptor<DynamicEntity> entityCaptor = ArgumentCaptor.forClass(DynamicEntity.class);
+    Mockito.verify(validationEngine).validateAttribute(entityCaptor.capture(), Mockito.eq("email"), Mockito.eq("a@b.com"));
+    assertEquals(entityConfiguration, entityCaptor.getValue().getConfiguration());
+  }
+
+  @Test
+  @DisplayName("test validateAttribute: should throw when entity is unknown")
+  void testValidateAttributeShouldThrowWhenEntityUnknown() {
+    Mockito.when(configurationService.getEntityConfiguration("users")).thenReturn(Optional.empty());
+
+    ApiException ex = assertThrows(ApiException.class, () -> service.validateAttribute("users", "email", "a@b.com"));
+
+    assertEquals(404, ex.getStatusCode());
+    assertEquals("error.entity.unknown", ex.getError().key());
+    assertEquals(Map.of("entity", "users"), ex.getError().context());
+  }
 }

src/test/java/io/github/linagora/linid/im/plugin/validation/ValidationEngineImplTest.java

@@ -223,6 +223,93 @@ public Optional<I18nMessage> validate(ValidationConfiguration configuration, Obj
     assertFalse(errors.isEmpty());
   }
 
+  @Test
+  @DisplayName("test validateAttribute: should not throw when validation succeeds")
+  void testValidateAttributeShouldNotThrow() {
+    var plugin = Mockito.spy(new DummyPlugin());
+
+    var config = new ValidationConfiguration();
+    config.setName("val1");
+    config.setType("type1");
+
+    var attrConfig = new AttributeConfiguration();
+    attrConfig.setName("email");
+    attrConfig.setValidations(List.of(config));
+
+    var entityConfig = new EntityConfiguration();
+    entityConfig.setName("users");
+    entityConfig.setAttributes(List.of(attrConfig));
+
+    var entity = Mockito.mock(DynamicEntity.class);
+    Mockito.when(entity.getConfiguration()).thenReturn(entityConfig);
+
+    Mockito.when(configurationService.getValidationConfiguration("val1")).thenReturn(Optional.empty());
+    Mockito.when(validationRegistry.getPlugins()).thenReturn(List.of(plugin));
+
+    assertDoesNotThrow(() -> validationEngine.validateAttribute(entity, "email", "a@b.com"));
+  }
+
+  @Test
+  @DisplayName("test validateAttribute: should throw 404 when attribute does not exist")
+  void testValidateAttributeShouldThrowWhenAttributeUnknown() {
+    var entityConfig = new EntityConfiguration();
+    entityConfig.setName("users");
+    entityConfig.setAttributes(List.of());
+
+    var entity = Mockito.mock(DynamicEntity.class);
+    Mockito.when(entity.getConfiguration()).thenReturn(entityConfig);
+
+    ApiException ex = assertThrows(ApiException.class, () -> validationEngine.validateAttribute(entity, "email", "a@b.com"));
+    assertEquals(404, ex.getStatusCode());
+    assertEquals("error.attribute.unknown", ex.getError().key());
+    assertEquals("users", ex.getError().context().get("entity"));
+    assertEquals("email", ex.getError().context().get("attribute"));
+  }
+
+  @Test
+  @DisplayName("test validateAttribute: should throw 400 when validation fails")
+  void testValidateAttributeShouldThrowWhenInvalid() {
+    var plugin = Mockito.spy(new DummyPlugin() {
+      @Override
+      public Optional<I18nMessage> validate(ValidationConfiguration configuration, Object value) {
+        return Optional.of(I18nMessage.of("error.test", Map.of("reason", "invalid")));
+      }
+    });
+
+    var config = new ValidationConfiguration();
+    config.setName("val1");
+    config.setType("type1");
+
+    var attrConfig = new AttributeConfiguration();
+    attrConfig.setName("email");
+    attrConfig.setValidations(List.of(config));
+
+    var entityConfig = new EntityConfiguration();
+    entityConfig.setName("users");
+    entityConfig.setAttributes(List.of(attrConfig));
+
+    var entity = Mockito.mock(DynamicEntity.class);
+    Mockito.when(entity.getConfiguration()).thenReturn(entityConfig);
+
+    Mockito.when(configurationService.getValidationConfiguration("val1")).thenReturn(Optional.empty());
+    Mockito.when(validationRegistry.getPlugins()).thenReturn(List.of(plugin));
+
+    ApiException ex = assertThrows(ApiException.class, () -> validationEngine.validateAttribute(entity, "email", "not-an-email"));
+    assertEquals(400, ex.getStatusCode());
+    assertEquals("error.entity.attributes", ex.getError().key());
+    assertEquals("users", ex.getError().context().get("entity"));
+
+    var errors = (List<?>) ex.getDetails().get("errors");
+    assertNotNull(errors);
+    assertEquals(1, errors.size());
+
+    var error = (I18nMessage) errors.get(0);
+    assertEquals("error.test", error.key());
+    assertEquals("invalid", error.context().get("reason"));
+    assertEquals("users", error.context().get("entity"));
+    assertEquals("email", error.context().get("attribute"));
+  }
+
 
   public static class DummyPlugin implements ValidationPlugin {
     @Override