Create duplicate invariant key validator

src/Firely.Fhir.Validation.Compilation.Shared/EnterpriseSchemaBuilders/StructureDefinitionBuilder.cs

@@ -0,0 +1,20 @@
+using Hl7.Fhir.Specification.Navigation;
+using System.Collections.Generic;
+
+namespace Firely.Fhir.Validation.Compilation
+{
+    /// <summary>
+    /// The schema builder for the <see cref="ElementDefinitionValidator"/>.
+    /// </summary>
+    public class StructureDefinitionBuilder : ISchemaBuilder
+    {
+        /// <inheritdoc/>
+        public IEnumerable<IAssertion> Build(ElementDefinitionNavigator nav, ElementConversionMode? conversionMode = ElementConversionMode.Full)
+        {
+            if (nav.Current.Path == "StructureDefinition")
+            {
+                yield return new StructureDefinitionValidator();
+            };
+        }
+    }
+}

src/Firely.Fhir.Validation.Compilation.Shared/Firely.Fhir.Validation.Compilation.Shared.projitems

@@ -11,6 +11,7 @@
   <ItemGroup>
     <Compile Include="$(MSBuildThisFileDirectory)ElementConversionMode.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)EnterpriseSchemaBuilders\ElementDefinitionBuilder.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)EnterpriseSchemaBuilders\StructureDefinitionBuilder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SchemaBuilderExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SchemaBuilders\BaseSchemaBuilder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SchemaBuilders\CardinalityBuilder.cs" />

src/Firely.Fhir.Validation.Compilation.Shared/SchemaBuilders/StandardBuilders.cs

@@ -33,7 +33,8 @@ public StandardBuilders(IAsyncResourceResolver source)
                     new ContentReferenceBuilder(),
                     new TypeReferenceBuilder(source),
                     new CanonicalBuilder(),
-                    new ElementDefinitionBuilder()
+                    new ElementDefinitionBuilder(),
+                    new StructureDefinitionBuilder()
                 };
         }
 

src/Firely.Fhir.Validation/EnterpriseValidators/StructureDefinitionValidator.cs

@@ -0,0 +1,68 @@
+using Hl7.Fhir.ElementModel;
+using Hl7.Fhir.Support;
+using Hl7.FhirPath.Sprache;
+using Newtonsoft.Json.Linq;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+
+namespace Firely.Fhir.Validation
+{
+    /// <summary>
+    /// An <see cref="ElementSchema"/> that represents a FHIR StructureDefinition
+    /// </summary>    
+    [DataContract]
+    public class StructureDefinitionValidator : IValidatable
+    {
+        /// <inheritdoc/>
+        public JToken ToJson() => new JProperty("elementDefinition", new JObject());
+
+        /// <inheritdoc/>
+        public ResultReport Validate(ITypedElement input, ValidationContext vc, ValidationState state)
+        {
+            //this can be expanded with other validate functionality
+            var evidence = validateInvariantUniqueness(input, state).ToList();
+
+            return ResultReport.FromEvidence(evidence);
+        }
+
+        /// <summary>
+        /// Validates if the invariants defined in the snapshot and differentials have a unique key. 
+        /// Duplicate keys can exist when the element paths are also the same (e.g. in slices).
+        /// </summary>
+        /// <param name="input"></param>
+        /// <param name="state"></param>
+        /// <returns></returns>
+        private static IEnumerable<ResultReport> validateInvariantUniqueness(ITypedElement input, ValidationState state)
+        {
+            var snapshotElements = input.Children("snapshot").SelectMany(c => c.Children("element"));
+            var diffElements = input.Children("differential").SelectMany(c => c.Children("element"));
+
+            var snapshotEvidence = validateInvariantUniqueness(snapshotElements);
+            var diffEvidence = validateInvariantUniqueness(diffElements);
+
+            return snapshotEvidence.Concat(diffEvidence).Select(i => i.AsResult(input, state));
+        }
+
+        private static List<IssueAssertion> validateInvariantUniqueness(IEnumerable<ITypedElement> elements)
+        {
+            //Selects the combination of key and elementDefintion path for the duplicate keys where the paths are not also the same.
+
+            IEnumerable<(string Key, string Path)> PathsPerInvariantKey = elements
+                                     .SelectMany(e => e.Children("constraint")
+                                                       .Select(c => (Key: c.Children("key")
+                                                                           .Single().Value.ToString(),
+                                                                    Path: e.Children("path")
+                                                                           .Single().Value.ToString())));
+
+            IEnumerable<(string Key, IEnumerable<string> Paths)> PathsPerDuplicateInvariantKey = PathsPerInvariantKey.GroupBy(pair => pair.Key)
+                                                                                     .Select(group => (Key: group.Key, Paths: group.Select(pair => pair.Path) // select all paths, per invariant key
+                                                                                                            .Distinct())) //Distinct to remove paths that are encountered multiple times per invariant
+                                                                                     .Where(kv => kv.Paths.Count() > 1); //Remove entries that only have a single path. These are not incorrect.
+
+            return PathsPerDuplicateInvariantKey.Select(c => new IssueAssertion(Issue.PROFILE_ELEMENTDEF_INCORRECT, $"Duplicate key '{c.Key}' in paths: {string.Join(", ", c.Paths)}")).ToList();
+        }
+    }
+}
+
+#nullable restore

test/Firely.Fhir.Validation.Compilation.Tests.Shared/Firely.Fhir.Validation.Compilation.Tests.Shared.projitems

@@ -1804,6 +1804,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)FhirTests\WipValidator.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)IsExternalInit.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ResourceSchemaValidationTests.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)StructureDefinitionSchemaValidationTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)\SchemaBuilderFixture.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SimpleValidationsTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SlicingSchemaConverterTests.cs" />

test/Firely.Fhir.Validation.Compilation.Tests.Shared/StructureDefinitionSchemaValidationTests.cs

@@ -0,0 +1,105 @@
+using Firely.Fhir.Validation.Compilation.Tests;
+using FluentAssertions;
+using Hl7.Fhir.ElementModel;
+using Hl7.Fhir.Model;
+using System.Linq;
+using Xunit;
+
+namespace Firely.Fhir.Validation.Tests.Impl
+{
+    public class StructureDefinitionSchemaTests : IClassFixture<SchemaBuilderFixture>
+    {
+        internal SchemaBuilderFixture _fixture;
+
+        public StructureDefinitionSchemaTests(SchemaBuilderFixture fixture) => _fixture = fixture;
+
+
+        [Fact]
+        public void ValidateElementDefinitioninProfileValueType()
+        {
+            var structureDefSchema = _fixture.SchemaResolver.GetSchema("http://hl7.org/fhir/StructureDefinition/StructureDefinition");
+
+            var elementDef1 = new ElementDefinition
+            {
+                Path = "Patient.gender",
+                Constraint = new()
+                {
+                    new()
+                    {
+                        Key = "key1",
+                        Expression = "foo.bar"
+                    },
+                     new()
+                    {
+                        Key = "key2",
+                        Expression = "bar.foo"
+                    }
+                }
+            };
+            var elementDef2 = new ElementDefinition
+            {
+                Path = "Patient.gender",
+                Constraint = new()
+                {
+                    new()
+                    {
+                        Key = "key1",
+                        Expression = "foo.bar"
+                    },
+                }
+            };
+            var elementDef3 = new ElementDefinition
+            {
+                Path = "Patient.birthdate",
+                Constraint = new()
+                {
+                     new()
+                    {
+                        Key = "key2",
+                        Expression = "bar.foo"
+                    }
+                }
+            };
+            var elementDef4 = new ElementDefinition
+            {
+                Path = "Patient.birthdate",
+                Constraint = new()
+                {
+                     new()
+                    {
+                        Key = "key4",
+                        Expression = "bar.foo"
+                    }
+                }
+            };
+
+            var profile = new StructureDefinition
+            {
+                Snapshot = new()
+                {
+                    Element = new() {
+
+                        elementDef1,
+                        elementDef2,
+                        elementDef3,
+                        elementDef4
+                    }
+                },
+                Differential = new()
+                {
+                    Element = new() {
+
+                        elementDef1,
+                        elementDef2,
+                        elementDef3,
+                        elementDef4
+                    }
+                }
+            };
+
+            var results = structureDefSchema!.Validate(profile.ToTypedElement(), _fixture.NewValidationContext());
+
+            results.Warnings.Select(w => w.Message).Should().Contain($"Duplicate key 'key2' in paths: Patient.gender, Patient.birthdate");
+        }
+    }
+}