From b370490cce167b556378d7b0d62e1034179be27e Mon Sep 17 00:00:00 2001
From: Valentin Laurin <valentin.laurin@quickcase.app>
Date: Wed, 29 Jan 2025 17:24:35 +0000
Subject: [PATCH 1/5] Add `Metadata` enum

---
 .../sdk/spring/metadata/Metadata.java         |  49 +++++++
 .../sdk/spring/metadata/MetadataTest.java     | 124 ++++++++++++++++++
 2 files changed, 173 insertions(+)
 create mode 100644 src/main/java/app/quickcase/sdk/spring/metadata/Metadata.java
 create mode 100644 src/test/java/app/quickcase/sdk/spring/metadata/MetadataTest.java

diff --git a/src/main/java/app/quickcase/sdk/spring/metadata/Metadata.java b/src/main/java/app/quickcase/sdk/spring/metadata/Metadata.java
new file mode 100644
index 0000000..a5670b1
--- /dev/null
+++ b/src/main/java/app/quickcase/sdk/spring/metadata/Metadata.java
@@ -0,0 +1,49 @@
+package app.quickcase.sdk.spring.metadata;
+
+import lombok.NonNull;
+
+public enum Metadata {
+    WORKSPACE("[workspace]"),
+    TYPE("[type]"),
+    ID("[id]"),
+    TITLE("[title]"),
+    STATE("[state]"),
+    CLASSIFICATION("[classification]"),
+    CREATED_AT("[createdAt]"),
+    LAST_MODIFIED_AT("[lastModifiedAt]");
+
+    private final String path;
+
+    Metadata(String path) {
+        this.path = path;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public static Metadata fromPath(@NonNull String path) {
+        if (path.length() < 2) {
+            throw new IllegalArgumentException("Invalid metadata path: " + path);
+        }
+
+        var name = path.substring(1, path.length() - 1).toLowerCase();
+        return switch (name) {
+            case "workspace", "organisation", "jurisdiction" ->
+                    WORKSPACE;
+            case "type", "case_type" ->
+                    TYPE;
+            case "id", "reference", "case_reference" ->
+                    ID;
+            case "title" -> TITLE;
+            case "state" -> STATE;
+            case "classification", "security_classification" ->
+                    CLASSIFICATION;
+            case "createdat", "created", "created_date" ->
+                    CREATED_AT;
+            case "lastmodifiedat", "modified", "last_modified", "last_modified_date" ->
+                    LAST_MODIFIED_AT;
+            default -> throw new IllegalArgumentException("Invalid metadata path: " + path);
+        };
+    }
+}
diff --git a/src/test/java/app/quickcase/sdk/spring/metadata/MetadataTest.java b/src/test/java/app/quickcase/sdk/spring/metadata/MetadataTest.java
new file mode 100644
index 0000000..8809db6
--- /dev/null
+++ b/src/test/java/app/quickcase/sdk/spring/metadata/MetadataTest.java
@@ -0,0 +1,124 @@
+package app.quickcase.sdk.spring.metadata;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class MetadataTest {
+
+    @Nested
+    class FromPath {
+        @Test
+        @DisplayName("should throw error when path not valid")
+        void shouldThrowErrorWhenPathTooShort() {
+            var error = assertThrows(IllegalArgumentException.class, () -> Metadata.fromPath("["));
+            assertThat(error.getMessage(), equalTo("Invalid metadata path: ["));
+        }
+
+        @Test
+        @DisplayName("should throw error when path not valid")
+        void shouldThrowErrorWhenPathNotValid() {
+            var error = assertThrows(IllegalArgumentException.class, () -> Metadata.fromPath("[notValid]"));
+            assertThat(error.getMessage(), equalTo("Invalid metadata path: [notValid]"));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                "[workspace]",
+                "[WORKSPACE]", // Case insensitive
+                "[organisation]", // Legacy
+                "[jurisdiction]", // Legacy
+        })
+        @DisplayName("should return workspace metadata")
+        void shouldReturnWorkspace(String path) {
+            assertThat(Metadata.fromPath(path), is(Metadata.WORKSPACE));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                "[type]",
+                "[TYPE]", // Case insensitive
+                "[case_type]", // Legacy
+        })
+        @DisplayName("should return type metadata")
+        void shouldReturnType(String path) {
+            assertThat(Metadata.fromPath(path), is(Metadata.TYPE));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                "[id]",
+                "[ID]", // Case insensitive
+                "[reference]", // Legacy
+                "[case_reference]", // Legacy
+        })
+        @DisplayName("should return id metadata")
+        void shouldReturnId(String path) {
+            assertThat(Metadata.fromPath(path), is(Metadata.ID));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                "[title]",
+                "[TITLE]", // Case insensitive
+        })
+        @DisplayName("should return title metadata")
+        void shouldReturnTitle(String path) {
+            assertThat(Metadata.fromPath(path), is(Metadata.TITLE));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                "[state]",
+                "[STATE]", // Case insensitive
+        })
+        @DisplayName("should return state metadata")
+        void shouldReturnState(String path) {
+            assertThat(Metadata.fromPath(path), is(Metadata.STATE));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                "[classification]",
+                "[CLASSIFICATION]", // Case insensitive
+                "[security_classification]", // Legacy
+        })
+        @DisplayName("should return classification metadata")
+        void shouldReturnClassification(String path) {
+            assertThat(Metadata.fromPath(path), is(Metadata.CLASSIFICATION));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                "[createdat]",
+                "[CreatedAt]", // Case insensitive
+                "[created]", // Legacy
+                "[created_date]", // Legacy
+        })
+        @DisplayName("should return createdAt metadata")
+        void shouldReturnCreatedAt(String path) {
+            assertThat(Metadata.fromPath(path), is(Metadata.CREATED_AT));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                "[lastmodifiedat]",
+                "[LastModifiedAt]", // Case insensitive
+                "[modified]", // Legacy
+                "[last_modified]", // Legacy
+                "[last_modified_date]", // Legacy
+        })
+        @DisplayName("should return lastModifiedAt metadata")
+        void shouldReturnLastModifiedAt(String path) {
+            assertThat(Metadata.fromPath(path), is(Metadata.LAST_MODIFIED_AT));
+        }
+    }
+
+}
\ No newline at end of file

From 57785076b5494d064b1a8b4171c064e3f10d0460 Mon Sep 17 00:00:00 2001
From: Valentin Laurin <valentin.laurin@quickcase.app>
Date: Thu, 30 Jan 2025 12:57:35 +0000
Subject: [PATCH 2/5] Add field path support

---
 .../sdk/spring/path/DataFieldPath.java        | 13 ++++
 .../quickcase/sdk/spring/path/FieldPath.java  | 38 +++++++++
 .../sdk/spring/path/MetadataFieldPath.java    | 20 +++++
 .../sdk/spring/path/FieldPathTest.java        | 77 +++++++++++++++++++
 4 files changed, 148 insertions(+)
 create mode 100644 src/main/java/app/quickcase/sdk/spring/path/DataFieldPath.java
 create mode 100644 src/main/java/app/quickcase/sdk/spring/path/FieldPath.java
 create mode 100644 src/main/java/app/quickcase/sdk/spring/path/MetadataFieldPath.java
 create mode 100644 src/test/java/app/quickcase/sdk/spring/path/FieldPathTest.java

diff --git a/src/main/java/app/quickcase/sdk/spring/path/DataFieldPath.java b/src/main/java/app/quickcase/sdk/spring/path/DataFieldPath.java
new file mode 100644
index 0000000..340ff9c
--- /dev/null
+++ b/src/main/java/app/quickcase/sdk/spring/path/DataFieldPath.java
@@ -0,0 +1,13 @@
+package app.quickcase.sdk.spring.path;
+
+import java.util.regex.Pattern;
+
+import lombok.NonNull;
+
+public final class DataFieldPath extends FieldPath {
+    public static final Pattern PATTERN = Pattern.compile("^[a-zA-Z0-9_]+(?:\\[(?:id:[a-zA-Z0-9_]+)|(?:[0-9]+)])?(?:\\.[a-zA-Z0-9_]+(?:\\[(?:id:[a-zA-Z0-9_]+)|(?:[0-9]+)])?)*$");
+
+    DataFieldPath(@NonNull String path) {
+        super(path);
+    }
+}
diff --git a/src/main/java/app/quickcase/sdk/spring/path/FieldPath.java b/src/main/java/app/quickcase/sdk/spring/path/FieldPath.java
new file mode 100644
index 0000000..ca37cb6
--- /dev/null
+++ b/src/main/java/app/quickcase/sdk/spring/path/FieldPath.java
@@ -0,0 +1,38 @@
+package app.quickcase.sdk.spring.path;
+
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+
+@EqualsAndHashCode
+abstract public class FieldPath {
+    protected final String path;
+
+    protected FieldPath(@NonNull String path) {
+        this.path = path;
+    }
+
+    public static FieldPath of(@NonNull String path) {
+        if (MetadataFieldPath.PATTERN.matcher(path).matches()) {
+            return ofMetadata(path);
+        }
+
+        return ofData(path);
+    }
+
+    public static MetadataFieldPath ofMetadata(@NonNull String path) {
+        return new MetadataFieldPath(path);
+    }
+
+    public static DataFieldPath ofData(@NonNull String path) {
+        if (!DataFieldPath.PATTERN.matcher(path).matches()) {
+            throw new IllegalArgumentException("Invalid data field path: " + path);
+        }
+
+        return new DataFieldPath(path);
+    }
+
+    @Override
+    public String toString() {
+        return path;
+    }
+}
diff --git a/src/main/java/app/quickcase/sdk/spring/path/MetadataFieldPath.java b/src/main/java/app/quickcase/sdk/spring/path/MetadataFieldPath.java
new file mode 100644
index 0000000..75dbcc2
--- /dev/null
+++ b/src/main/java/app/quickcase/sdk/spring/path/MetadataFieldPath.java
@@ -0,0 +1,20 @@
+package app.quickcase.sdk.spring.path;
+
+import java.util.regex.Pattern;
+
+import app.quickcase.sdk.spring.metadata.Metadata;
+import lombok.Getter;
+import lombok.NonNull;
+
+@Getter
+public final class MetadataFieldPath extends FieldPath {
+    public static final Pattern PATTERN = Pattern.compile("^\\[[a-zA-Z_]+]$");
+
+    final private Metadata metadata;
+
+    MetadataFieldPath(@NonNull String path) {
+        super(path);
+        metadata = Metadata.fromPath(path);
+    }
+
+}
diff --git a/src/test/java/app/quickcase/sdk/spring/path/FieldPathTest.java b/src/test/java/app/quickcase/sdk/spring/path/FieldPathTest.java
new file mode 100644
index 0000000..b4ce3ed
--- /dev/null
+++ b/src/test/java/app/quickcase/sdk/spring/path/FieldPathTest.java
@@ -0,0 +1,77 @@
+package app.quickcase.sdk.spring.path;
+
+import app.quickcase.sdk.spring.metadata.Metadata;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class FieldPathTest {
+
+    @Nested
+    class OfMetadata {
+        @Test
+        @DisplayName("should throw error when path is not for metadata")
+        void shouldThrowErrorWhenNotMetadata() {
+            var error = assertThrows(IllegalArgumentException.class, () -> FieldPath.ofMetadata("field1"));
+            assertThat(error.getMessage(), equalTo("Invalid metadata path: field1"));
+        }
+
+        @Test
+        @DisplayName("should return metadata field path")
+        void shouldReturnMetadataFieldPath() {
+            var path = FieldPath.ofMetadata("[state]");
+
+            assertThat(path.toString(), equalTo("[state]"));
+            assertThat(path.getMetadata(), is(Metadata.STATE));
+        }
+    }
+
+    @Nested
+    class OfData {
+        @Test
+        @DisplayName("should throw error when path is not for data field")
+        void shouldThrowErrorWhenNotData() {
+            var error = assertThrows(IllegalArgumentException.class, () -> FieldPath.ofData("[state]"));
+            assertThat(error.getMessage(), equalTo("Invalid data field path: [state]"));
+        }
+
+        @Test
+        @DisplayName("should return data field path")
+        void shouldReturnDataFieldPath() {
+            var path = FieldPath.ofData("field1.child2");
+
+            assertThat(path.toString(), equalTo("field1.child2"));
+        }
+    }
+
+    @Nested
+    class Of {
+        @Test
+        @DisplayName("should return metadata field path")
+        void shouldReturnMetadataFieldPath() {
+            var path = FieldPath.of("[state]");
+
+            assertAll(
+                    () -> assertThat(path.toString(), equalTo("[state]")),
+                    () -> assertThat(path, is(instanceOf(MetadataFieldPath.class)))
+            );
+        }
+
+        @Test
+        @DisplayName("should return data field path")
+        void shouldReturnDataFieldPath() {
+            var path = FieldPath.of("field1.child2");
+
+            assertAll(
+                    () -> assertThat(path.toString(), equalTo("field1.child2")),
+                    () -> assertThat(path, is(instanceOf(DataFieldPath.class)))
+            );
+        }
+    }
+
+}
\ No newline at end of file

From 97b47d5c1702ccfc71f892300d8ba8b5bac231c0 Mon Sep 17 00:00:00 2001
From: Valentin Laurin <valentin.laurin@quickcase.app>
Date: Thu, 30 Jan 2025 13:00:05 +0000
Subject: [PATCH 3/5] Add normalised definition model for schema

---
 .../spring/definition/model/DataField.java    | 45 +++++++++++++++++++
 .../sdk/spring/definition/model/Field.java    | 18 ++++++++
 .../definition/model/MetadataField.java       | 22 +++++++++
 .../spring/definition/model/RecordType.java   | 10 +++++
 .../sdk/spring/definition/model/Schema.java   | 13 ++++++
 5 files changed, 108 insertions(+)
 create mode 100644 src/main/java/app/quickcase/sdk/spring/definition/model/DataField.java
 create mode 100644 src/main/java/app/quickcase/sdk/spring/definition/model/Field.java
 create mode 100644 src/main/java/app/quickcase/sdk/spring/definition/model/MetadataField.java
 create mode 100644 src/main/java/app/quickcase/sdk/spring/definition/model/RecordType.java
 create mode 100644 src/main/java/app/quickcase/sdk/spring/definition/model/Schema.java

diff --git a/src/main/java/app/quickcase/sdk/spring/definition/model/DataField.java b/src/main/java/app/quickcase/sdk/spring/definition/model/DataField.java
new file mode 100644
index 0000000..1c10fbd
--- /dev/null
+++ b/src/main/java/app/quickcase/sdk/spring/definition/model/DataField.java
@@ -0,0 +1,45 @@
+package app.quickcase.sdk.spring.definition.model;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import lombok.Builder;
+import lombok.NonNull;
+import lombok.Singular;
+
+@Builder
+public record DataField(
+    @NonNull String id,
+    @NonNull String name,
+    String label,
+    String hint,
+    @NonNull String type,
+    @Singular List<Option> options,
+    Content content,
+    @Singular Map<String, DataField> members,
+    Validation validation,
+    Field.Display display,
+    @NonNull @Singular("acl") Map<String, Short> acl,
+    @NonNull String classification
+) implements Field {
+    @Builder
+    public record Validation(
+            Integer min,
+            Optional<Integer> max,
+            Optional<String> pattern
+    ) {}
+
+    @Builder
+    public record Option(
+            @NonNull String code,
+            @NonNull String label
+    ) {}
+
+    @Builder
+    public record Content(
+            @NonNull String type,
+            @Singular List<Option> options,
+            @Singular Map<String, DataField> members
+    ) {}
+}
diff --git a/src/main/java/app/quickcase/sdk/spring/definition/model/Field.java b/src/main/java/app/quickcase/sdk/spring/definition/model/Field.java
new file mode 100644
index 0000000..c067639
--- /dev/null
+++ b/src/main/java/app/quickcase/sdk/spring/definition/model/Field.java
@@ -0,0 +1,18 @@
+package app.quickcase.sdk.spring.definition.model;
+
+import java.util.Map;
+import java.util.Optional;
+
+import lombok.NonNull;
+
+public interface Field {
+    @NonNull String id();
+    @NonNull String name();
+    String label();
+    Field.Display display();
+
+    interface Display {
+        String mode();
+        Map<String, String> parameters();
+    }
+}
diff --git a/src/main/java/app/quickcase/sdk/spring/definition/model/MetadataField.java b/src/main/java/app/quickcase/sdk/spring/definition/model/MetadataField.java
new file mode 100644
index 0000000..a7c92c9
--- /dev/null
+++ b/src/main/java/app/quickcase/sdk/spring/definition/model/MetadataField.java
@@ -0,0 +1,22 @@
+package app.quickcase.sdk.spring.definition.model;
+
+import java.util.List;
+
+import lombok.Builder;
+import lombok.NonNull;
+import lombok.Singular;
+
+@Builder
+public record MetadataField(
+        @NonNull String id,
+        @NonNull String name,
+        String label,
+        @Singular List<MetadataField.Option> options,
+        Field.Display display
+) implements Field{
+    @Builder
+    public record Option(
+            @NonNull String code,
+            @NonNull String label
+    ) {}
+}
diff --git a/src/main/java/app/quickcase/sdk/spring/definition/model/RecordType.java b/src/main/java/app/quickcase/sdk/spring/definition/model/RecordType.java
new file mode 100644
index 0000000..46187aa
--- /dev/null
+++ b/src/main/java/app/quickcase/sdk/spring/definition/model/RecordType.java
@@ -0,0 +1,10 @@
+package app.quickcase.sdk.spring.definition.model;
+
+import lombok.Builder;
+import lombok.NonNull;
+
+@Builder
+public record RecordType(
+        @NonNull Schema schema
+) {
+}
diff --git a/src/main/java/app/quickcase/sdk/spring/definition/model/Schema.java b/src/main/java/app/quickcase/sdk/spring/definition/model/Schema.java
new file mode 100644
index 0000000..dc524fc
--- /dev/null
+++ b/src/main/java/app/quickcase/sdk/spring/definition/model/Schema.java
@@ -0,0 +1,13 @@
+package app.quickcase.sdk.spring.definition.model;
+
+import java.util.Map;
+
+import lombok.Builder;
+import lombok.NonNull;
+import lombok.Singular;
+
+@Builder
+public record Schema(
+        @NonNull @Singular Map<String, DataField> fields
+) {
+}

From e153e6aeda1c5d764d54d464d96dfbb64b2b8e7d Mon Sep 17 00:00:00 2001
From: Valentin Laurin <valentin.laurin@quickcase.app>
Date: Mon, 3 Feb 2025 17:39:13 +0000
Subject: [PATCH 4/5] Add definition field path-based extraction

---
 .../definition/DefinitionExtractor.java       | 131 ++++++++
 .../sdk/spring/path/DataFieldPath.java        |  33 +-
 .../definition/DefinitionExtractorTest.java   | 291 ++++++++++++++++++
 3 files changed, 454 insertions(+), 1 deletion(-)
 create mode 100644 src/main/java/app/quickcase/sdk/spring/definition/DefinitionExtractor.java
 create mode 100644 src/test/java/app/quickcase/sdk/spring/definition/DefinitionExtractorTest.java

diff --git a/src/main/java/app/quickcase/sdk/spring/definition/DefinitionExtractor.java b/src/main/java/app/quickcase/sdk/spring/definition/DefinitionExtractor.java
new file mode 100644
index 0000000..7fd6933
--- /dev/null
+++ b/src/main/java/app/quickcase/sdk/spring/definition/DefinitionExtractor.java
@@ -0,0 +1,131 @@
+package app.quickcase.sdk.spring.definition;
+
+import java.util.ArrayDeque;
+import java.util.Map;
+import java.util.Optional;
+
+import app.quickcase.sdk.spring.definition.model.DataField;
+import app.quickcase.sdk.spring.definition.model.Field;
+import app.quickcase.sdk.spring.definition.model.MetadataField;
+import app.quickcase.sdk.spring.definition.model.RecordType;
+import app.quickcase.sdk.spring.path.DataFieldPath;
+import app.quickcase.sdk.spring.path.FieldPath;
+import app.quickcase.sdk.spring.path.MetadataFieldPath;
+
+public class DefinitionExtractor {
+
+    private final RecordType type;
+
+    public DefinitionExtractor(RecordType type) {
+        this.type = type;
+    }
+
+    public Optional<? extends Field> extractField(FieldPath path) {
+        return switch (path) {
+            case MetadataFieldPath metadataFieldPath -> Optional.of(extractField(metadataFieldPath));
+            case DataFieldPath dataFieldPath -> extractField(dataFieldPath);
+            default -> throw new IllegalArgumentException("Unsupported field path: " + path);
+        };
+    }
+
+    public MetadataField extractField(MetadataFieldPath path) {
+        return switch (path.getMetadata()) {
+            case WORKSPACE -> MetadataField.builder()
+                                           .id(path.toString())
+                                           .name("Workspace")
+                                           .label("Workspace")
+                                           .build();
+            case TYPE -> MetadataField.builder()
+                                      .id(path.toString())
+                                      .name("Type")
+                                      .label("Record type")
+                                      .build();
+            case ID -> MetadataField.builder()
+                                    .id(path.toString())
+                                    .name("ID")
+                                    .label("Record ID")
+                                    .build();
+            case TITLE -> MetadataField.builder()
+                                       .id(path.toString())
+                                       .name("Title")
+                                       .label("Record title")
+                                       .build();
+            case STATE -> MetadataField.builder()
+                                       .id(path.toString())
+                                       .name("State")
+                                       .label("Record state")
+                                       .build();
+            case CREATED_AT -> MetadataField.builder()
+                                            .id(path.toString())
+                                            .name("Created at")
+                                            .label("Date and time of creation")
+                                            .build();
+            case LAST_MODIFIED_AT -> MetadataField.builder()
+                                            .id(path.toString())
+                                            .name("Last modified at")
+                                            .label("Date and time of last modification")
+                                            .build();
+            case CLASSIFICATION -> MetadataField.builder()
+                                                .id(path.toString())
+                                                .name("Classification")
+                                                .label("Default record classification")
+                                                .build();
+        };
+    }
+
+    public Optional<DataField> extractField(DataFieldPath path) {
+        return extractDataField(type.schema().fields(), new ArrayDeque<>(path.elements()));
+    }
+
+    private Optional<DataField> extractDataField(Map<String, DataField> fields, ArrayDeque<DataFieldPath.Element> pathElements) {
+        var element = pathElements.removeFirst();
+        var field = fields.get(element.getIdentifier());
+
+        if (field == null && element.isCollectionItem()) {
+            return extractDataFieldCollectionItem(fields, element.getCollectionIdentifier(), pathElements);
+        }
+
+        if (field == null) {
+            return Optional.empty();
+        }
+
+        if (!pathElements.isEmpty()) {
+            if (field.members() == null) {
+                return Optional.empty();
+            }
+
+            return extractDataField(field.members(), pathElements);
+        }
+
+        return Optional.of(field);
+    }
+
+    private Optional<DataField> extractDataFieldCollectionItem(Map<String, DataField> fields, String collectionId, ArrayDeque<DataFieldPath.Element> elements) {
+        var field = fields.get(collectionId);
+
+        if (field == null) {
+            return Optional.empty();
+        }
+
+        if (!elements.isEmpty()) {
+            var itemFieldBuilder = DataField.builder()
+                                     .id(field.id() + "[].value")
+                                     .name(field.name())
+                                     .label(field.label())
+                                     .type(field.content().type())
+                                     .acl(field.acl())
+                                     .classification(field.classification());
+            if (field.content().members() != null) {
+                itemFieldBuilder.members(field.content().members());
+            }
+
+            if (field.content().options() != null) {
+                itemFieldBuilder.options(field.content().options());
+            }
+
+            return extractDataField(Map.of("value", itemFieldBuilder.build()), elements);
+        }
+
+        return Optional.of(field);
+    }
+}
diff --git a/src/main/java/app/quickcase/sdk/spring/path/DataFieldPath.java b/src/main/java/app/quickcase/sdk/spring/path/DataFieldPath.java
index 340ff9c..127de5f 100644
--- a/src/main/java/app/quickcase/sdk/spring/path/DataFieldPath.java
+++ b/src/main/java/app/quickcase/sdk/spring/path/DataFieldPath.java
@@ -1,13 +1,44 @@
 package app.quickcase.sdk.spring.path;
 
+import java.util.Arrays;
+import java.util.List;
 import java.util.regex.Pattern;
 
+import lombok.Getter;
 import lombok.NonNull;
 
 public final class DataFieldPath extends FieldPath {
-    public static final Pattern PATTERN = Pattern.compile("^[a-zA-Z0-9_]+(?:\\[(?:id:[a-zA-Z0-9_]+)|(?:[0-9]+)])?(?:\\.[a-zA-Z0-9_]+(?:\\[(?:id:[a-zA-Z0-9_]+)|(?:[0-9]+)])?)*$");
+    public static final Pattern PATTERN = Pattern.compile("^[a-zA-Z0-9_]+(?:\\[(?:(?:id:[a-zA-Z0-9_]+)|(?:[0-9]+))?])?(?:\\.[a-zA-Z0-9_]+(?:\\[(?:(?:id:[a-zA-Z0-9_]+)|(?:[0-9]+))?])?)*$");
+    public static final Pattern COLLECTION_ITEM_PATTERN = Pattern.compile("^(?<collectionId>[a-zA-Z0-9_]+)\\[(?:(?:id:(?<itemId>[a-zA-Z0-9_]+))|(?<itemIndex>[0-9]+))?]$");
 
     DataFieldPath(@NonNull String path) {
         super(path);
     }
+
+    public List<Element> elements() {
+        return Arrays.stream(path.split("\\."))
+                     .map(Element::new)
+                     .toList();
+    }
+
+    @Getter
+    public static class Element {
+        private final String identifier;
+        private final boolean collectionItem;
+        private final String collectionIdentifier;
+        private final String itemId;
+        private final Integer itemIndex;
+
+        public Element(@NonNull String identifier) {
+            this.identifier = identifier;
+
+            var collectionItemMatcher = DataFieldPath.COLLECTION_ITEM_PATTERN.matcher(identifier);
+            collectionItem = collectionItemMatcher.find();
+
+            collectionIdentifier = collectionItem ? collectionItemMatcher.group("collectionId") : null;
+            itemId = collectionItem ? collectionItemMatcher.group("itemId") : null;
+            var index = collectionItem ? collectionItemMatcher.group("itemIndex") : null;
+            itemIndex = (index != null) ? Integer.parseInt(index) : null;
+        }
+    }
 }
diff --git a/src/test/java/app/quickcase/sdk/spring/definition/DefinitionExtractorTest.java b/src/test/java/app/quickcase/sdk/spring/definition/DefinitionExtractorTest.java
new file mode 100644
index 0000000..2cfe795
--- /dev/null
+++ b/src/test/java/app/quickcase/sdk/spring/definition/DefinitionExtractorTest.java
@@ -0,0 +1,291 @@
+package app.quickcase.sdk.spring.definition;
+
+import java.util.Map;
+
+import app.quickcase.sdk.spring.definition.model.DataField;
+import app.quickcase.sdk.spring.definition.model.MetadataField;
+import app.quickcase.sdk.spring.definition.model.RecordType;
+import app.quickcase.sdk.spring.definition.model.Schema;
+import app.quickcase.sdk.spring.path.FieldPath;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+
+class DefinitionExtractorTest {
+
+    @Nested
+    class ExtractMetadataField {
+        @Test
+        @DisplayName("should return workspace field")
+        void shouldReturnWorkspaceField() {
+            var extractor = new DefinitionExtractor(recordType());
+            var field = extractor.extractField(FieldPath.ofMetadata("[workspace]"));
+
+            assertThat(field, equalTo(
+                    MetadataField.builder()
+                                 .id("[workspace]")
+                                 .name("Workspace")
+                                 .label("Workspace")
+                                 .build()
+            ));
+        }
+
+        @Test
+        @DisplayName("should return type field")
+        void shouldReturnTypeField() {
+            var extractor = new DefinitionExtractor(recordType());
+            var field = extractor.extractField(FieldPath.ofMetadata("[type]"));
+
+            assertThat(field, equalTo(
+                    MetadataField.builder()
+                                 .id("[type]")
+                                 .name("Type")
+                                 .label("Record type")
+                                 .build()
+            ));
+        }
+
+        @Test
+        @DisplayName("should return ID field")
+        void shouldReturnIdField() {
+            var extractor = new DefinitionExtractor(recordType());
+            var field = extractor.extractField(FieldPath.ofMetadata("[id]"));
+
+            assertThat(field, equalTo(
+                    MetadataField.builder()
+                                 .id("[id]")
+                                 .name("ID")
+                                 .label("Record ID")
+                                 .build()
+            ));
+        }
+
+        @Test
+        @DisplayName("should return title field")
+        void shouldReturnTitleField() {
+            var extractor = new DefinitionExtractor(recordType());
+            var field = extractor.extractField(FieldPath.ofMetadata("[title]"));
+
+            assertThat(field, equalTo(
+                    MetadataField.builder()
+                                 .id("[title]")
+                                 .name("Title")
+                                 .label("Record title")
+                                 .build()
+            ));
+        }
+
+        @Test
+        @DisplayName("should return state field")
+        void shouldReturnStateField() {
+            var extractor = new DefinitionExtractor(recordType());
+            var field = extractor.extractField(FieldPath.ofMetadata("[state]"));
+
+            assertThat(field, equalTo(
+                    MetadataField.builder()
+                                 .id("[state]")
+                                 .name("State")
+                                 .label("Record state")
+                                 .build()
+            ));
+        }
+
+        @Test
+        @DisplayName("should return classification field")
+        void shouldReturnClassificationField() {
+            var extractor = new DefinitionExtractor(recordType());
+            var field = extractor.extractField(FieldPath.ofMetadata("[classification]"));
+
+            assertThat(field, equalTo(
+                    MetadataField.builder()
+                                 .id("[classification]")
+                                 .name("Classification")
+                                 .label("Default record classification")
+                                 .build()
+            ));
+        }
+
+        @Test
+        @DisplayName("should return createdAt field")
+        void shouldReturnCreatedAtField() {
+            var extractor = new DefinitionExtractor(recordType());
+            var field = extractor.extractField(FieldPath.ofMetadata("[createdAt]"));
+
+            assertThat(field, equalTo(
+                    MetadataField.builder()
+                                 .id("[createdAt]")
+                                 .name("Created at")
+                                 .label("Date and time of creation")
+                                 .build()
+            ));
+        }
+
+        @Test
+        @DisplayName("should return lastModifiedAt field")
+        void shouldReturnLastModifiedAtField() {
+            var extractor = new DefinitionExtractor(recordType());
+            var field = extractor.extractField(FieldPath.ofMetadata("[lastModifiedAt]"));
+
+            assertThat(field, equalTo(
+                    MetadataField.builder()
+                                 .id("[lastModifiedAt]")
+                                 .name("Last modified at")
+                                 .label("Date and time of last modification")
+                                 .build()
+            ));
+        }
+    }
+
+    @Nested
+    class ExtractDataField {
+        @Test
+        @DisplayName("should return empty when field does not exist in definition")
+        void shouldReturnEmptyWhenFieldDoesNotExist() {
+            var extractor = new DefinitionExtractor(recordType());
+
+            var field = extractor.extractField(FieldPath.ofData("notAField"));
+
+            assertThat(field.isEmpty(), is(true));
+        }
+
+        @Test
+        @DisplayName("should return definition of top level field found")
+        void shouldReturnTopLevelField() {
+            var type = recordType();
+            var extractor = new DefinitionExtractor(type);
+
+            var field = extractor.extractField(FieldPath.ofData("field1"));
+
+            assertThat(field.orElseThrow(), equalTo(
+                    type.schema().fields().get("field1")
+            ));
+        }
+
+        @Test
+        @DisplayName("should return definition of nested complex member field found")
+        void shouldReturnNestedComplexMemberField() {
+            var type = recordType();
+            var extractor = new DefinitionExtractor(type);
+
+            var field = extractor.extractField(FieldPath.ofData("complex1.member1.member11"));
+
+            assertThat(field.orElseThrow(), equalTo(
+                    type.schema().fields()
+                        .get("complex1")
+                        .members().get("member1")
+                        .members().get("member11")
+            ));
+        }
+
+        @Test
+        @DisplayName("should return definition of collection content found")
+        void shouldReturnCollectionContent() {
+            var type = recordType();
+            var extractor = new DefinitionExtractor(type);
+
+            var field = extractor.extractField(FieldPath.ofData("collection1[].value"));
+
+            var collectionField = type.schema().fields().get("collection1");
+            assertThat(field.orElseThrow(), equalTo(
+                    DataField.builder()
+                             .id("collection1[].value")
+                             .name(collectionField.name())
+                             .type(collectionField.content().type())
+                             .members(
+                                     collectionField.content().members()
+                             )
+                             .acl(collectionField.acl())
+                             .classification(collectionField.classification())
+                             .build()
+            ));
+        }
+
+        @Test
+        @DisplayName("should return definition of complex member found in collection content")
+        void shouldReturnComplexMemberInCollection() {
+            var type = recordType();
+            var extractor = new DefinitionExtractor(type);
+
+            var field = extractor.extractField(FieldPath.ofData("collection1[].value.member1"));
+
+            assertThat(field.orElseThrow(), equalTo(
+                    type.schema().fields().get("collection1").content().members().get("member1")
+            ));
+        }
+    }
+
+    private RecordType recordType() {
+        var fields = Map.of(
+                "field1",
+                DataField.builder()
+                         .id("field1")
+                         .name("Field 1")
+                         .type("text")
+                         .acl(Map.of())
+                         .classification("PUBLIC")
+                         .build(),
+                "complex1",
+                DataField.builder()
+                         .id("complex1")
+                         .name("Complex 1")
+                         .type("complex")
+                         .member(
+                                 "member1",
+                                 DataField.builder()
+                                          .id("member1")
+                                          .name("Member 1")
+                                          .type("complex")
+                                          .member(
+                                                  "member11",
+                                                  DataField.builder()
+                                                           .id("member11")
+                                                           .name("Member 11")
+                                                           .type("text")
+                                                           .acl(Map.of())
+                                                           .classification("PUBLIC")
+                                                           .build()
+                                          )
+                                          .acl(Map.of())
+                                          .classification("PUBLIC")
+                                          .build()
+                         )
+                         .acl(Map.of())
+                         .classification("PUBLIC")
+                         .build(),
+                "collection1",
+                DataField.builder()
+                         .id("collection1")
+                         .name("Collection 1")
+                         .type("collection")
+                         .content(
+                                 DataField.Content.builder()
+                                                  .type("complex")
+                                                  .member(
+                                                          "member1",
+                                                          DataField.builder()
+                                                                   .id("member1")
+                                                                   .name("Member 1")
+                                                                   .type("text")
+                                                                   .acl(Map.of())
+                                                                   .classification("PUBLIC")
+                                                                   .build()
+                                                  )
+                                                  .build()
+                         )
+                         .acl(Map.of())
+                         .classification("PUBLIC")
+                         .build()
+
+        );
+
+        return RecordType
+                .builder()
+                .schema(Schema.builder().fields(fields).build())
+                .build();
+    }
+
+}
\ No newline at end of file

From a384371052e9b36c0a1619ef2c46633ce2423b1f Mon Sep 17 00:00:00 2001
From: Valentin Laurin <valentin.laurin@quickcase.app>
Date: Tue, 4 Feb 2025 14:16:02 +0000
Subject: [PATCH 5/5] Add semantic condition validator

Validate condition's criteria field path against provided definition
---
 .../validate/ConditionValidator.java          |   9 ++
 .../validate/SemanticConditionValidator.java  |  46 ++++++++
 .../SemanticConditionValidatorTest.java       | 107 ++++++++++++++++++
 3 files changed, 162 insertions(+)
 create mode 100644 src/main/java/app/quickcase/sdk/spring/condition/validate/ConditionValidator.java
 create mode 100644 src/main/java/app/quickcase/sdk/spring/condition/validate/SemanticConditionValidator.java
 create mode 100644 src/test/java/app/quickcase/sdk/spring/condition/validate/SemanticConditionValidatorTest.java

diff --git a/src/main/java/app/quickcase/sdk/spring/condition/validate/ConditionValidator.java b/src/main/java/app/quickcase/sdk/spring/condition/validate/ConditionValidator.java
new file mode 100644
index 0000000..88a4957
--- /dev/null
+++ b/src/main/java/app/quickcase/sdk/spring/condition/validate/ConditionValidator.java
@@ -0,0 +1,9 @@
+package app.quickcase.sdk.spring.condition.validate;
+
+import java.util.Set;
+
+import app.quickcase.sdk.spring.condition.Condition;
+
+public interface ConditionValidator {
+    Set<String> validate(Condition condition);
+}
diff --git a/src/main/java/app/quickcase/sdk/spring/condition/validate/SemanticConditionValidator.java b/src/main/java/app/quickcase/sdk/spring/condition/validate/SemanticConditionValidator.java
new file mode 100644
index 0000000..e00e079
--- /dev/null
+++ b/src/main/java/app/quickcase/sdk/spring/condition/validate/SemanticConditionValidator.java
@@ -0,0 +1,46 @@
+package app.quickcase.sdk.spring.condition.validate;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import app.quickcase.sdk.spring.condition.Condition;
+import app.quickcase.sdk.spring.condition.Criteria;
+import app.quickcase.sdk.spring.definition.DefinitionExtractor;
+import app.quickcase.sdk.spring.path.FieldPath;
+
+public class SemanticConditionValidator implements ConditionValidator {
+
+    private final DefinitionExtractor fieldExtractor;
+
+    public SemanticConditionValidator(DefinitionExtractor fieldExtractor) {
+        this.fieldExtractor = fieldExtractor;
+    }
+
+    @Override
+    public Set<String> validate(Condition condition) {
+        var allPaths = Arrays.stream(condition.disjunctions())
+                             .flatMap(Arrays::stream)
+                             .map(Criteria::getPath)
+                             .collect(Collectors.toSet());
+
+        return allPaths.stream()
+                       .flatMap(this::validate)
+                       .collect(Collectors.toSet());
+    }
+
+    private Stream<String> validate(String path) {
+        try {
+            var fieldPath = FieldPath.of(path);
+
+            if (fieldExtractor.extractField(fieldPath).isEmpty()) {
+                return Stream.of("Path `" + path + "` does not exist");
+            }
+
+            return Stream.empty();
+        } catch (IllegalArgumentException e) {
+            return Stream.of("Path `" + path + "` is not valid");
+        }
+    }
+}
diff --git a/src/test/java/app/quickcase/sdk/spring/condition/validate/SemanticConditionValidatorTest.java b/src/test/java/app/quickcase/sdk/spring/condition/validate/SemanticConditionValidatorTest.java
new file mode 100644
index 0000000..5353bc5
--- /dev/null
+++ b/src/test/java/app/quickcase/sdk/spring/condition/validate/SemanticConditionValidatorTest.java
@@ -0,0 +1,107 @@
+package app.quickcase.sdk.spring.condition.validate;
+
+import java.util.Map;
+import java.util.Set;
+
+import app.quickcase.sdk.spring.condition.Condition;
+import app.quickcase.sdk.spring.condition.Criteria;
+import app.quickcase.sdk.spring.definition.DefinitionExtractor;
+import app.quickcase.sdk.spring.definition.model.DataField;
+import app.quickcase.sdk.spring.definition.model.RecordType;
+import app.quickcase.sdk.spring.definition.model.Schema;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+class SemanticConditionValidatorTest {
+
+    @Test
+    @DisplayName("should return empty set when all criteria path are valid")
+    void shouldReturnEmptySetWhenAllValid() {
+        var fieldExtractor = new DefinitionExtractor(recordType());
+        var validator = new SemanticConditionValidator(fieldExtractor);
+
+        var condition = new Condition(
+                new Criteria[][]{
+                        new Criteria[]{
+                                Criteria.builder().path("complex1").build()
+                        },
+                        new Criteria[]{
+                                Criteria.builder().path("complex1.member1").build(),
+                                Criteria.builder().path("complex1.member1.member11").build(),
+                        },
+                }
+        );
+
+        var errors = validator.validate(condition);
+
+        assertThat(errors, equalTo(Set.of()));
+    }
+
+    @Test
+    @DisplayName("should return errors for all invalid criteria paths")
+    void shouldReturnErrorsForInvalidCriteriaPaths() {
+        var fieldExtractor = new DefinitionExtractor(recordType());
+        var validator = new SemanticConditionValidator(fieldExtractor);
+
+        var condition = new Condition(
+                new Criteria[][]{
+                        new Criteria[]{
+                                Criteria.builder().path("invalid syntax").build()
+                        },
+                        new Criteria[]{
+                                Criteria.builder().path("complex1.member1").build(),
+                                Criteria.builder().path("fieldNotFound").build(),
+                        },
+                }
+        );
+
+        var errors = validator.validate(condition);
+
+        assertThat(errors, equalTo(Set.of(
+                "Path `fieldNotFound` does not exist",
+                "Path `invalid syntax` is not valid"
+        )));
+    }
+
+    private RecordType recordType() {
+        var fields = Map.of(
+                "complex1",
+                DataField.builder()
+                         .id("complex1")
+                         .name("Complex 1")
+                         .type("complex")
+                         .member(
+                                 "member1",
+                                 DataField.builder()
+                                          .id("member1")
+                                          .name("Member 1")
+                                          .type("complex")
+                                          .member(
+                                                  "member11",
+                                                  DataField.builder()
+                                                           .id("member11")
+                                                           .name("Member 11")
+                                                           .type("text")
+                                                           .acl(Map.of())
+                                                           .classification("PUBLIC")
+                                                           .build()
+                                          )
+                                          .acl(Map.of())
+                                          .classification("PUBLIC")
+                                          .build()
+                         )
+                         .acl(Map.of())
+                         .classification("PUBLIC")
+                         .build()
+
+        );
+
+        return RecordType
+                .builder()
+                .schema(Schema.builder().fields(fields).build())
+                .build();
+    }
+}
\ No newline at end of file