Merge pull request #2334 from Cratis:fix/fixes

Fix/fixes

Author: einari

Source/Infrastructure.Specs/Changes/for_Changeset/when_adding_changes/and_properties_changed_to_different_empty_array_than_child_added.cs

@@ -15,8 +15,10 @@ public class and_properties_changed_to_different_empty_array_than_child_added :
 
     void Establish()
     {
-        _itemsProperty = new PropertyPath("items");
-        _tagsProperty = new PropertyPath("tags");
+        // Create the array property paths using AddArrayIndex to match runtime behavior
+        // At runtime, ChildrenPropertyPath is created with AddArrayIndex, resulting in format "[propertyName]"
+        _itemsProperty = PropertyPath.Root.AddArrayIndex("items");
+        _tagsProperty = PropertyPath.Root.AddArrayIndex("tags");
 
         // Create a PropertiesChanged that sets tags to empty array
         var emptyArray = Array.Empty<object>();

Source/Infrastructure.Specs/Changes/for_Changeset/when_adding_changes/and_properties_changed_to_empty_array_then_child_added.cs

@@ -14,7 +14,9 @@ public class and_properties_changed_to_empty_array_then_child_added : given.a_ch
 
     void Establish()
     {
-        _itemsProperty = new PropertyPath("items");
+        // Create the array property path using AddArrayIndex to match runtime behavior
+        // At runtime, ChildrenPropertyPath is created with AddArrayIndex, resulting in format "[items]"
+        _itemsProperty = PropertyPath.Root.AddArrayIndex("items");
 
         // Create a PropertiesChanged that sets items to empty array
         var emptyArray = Array.Empty<object>();

Source/Infrastructure.Specs/Changes/for_Changeset/when_adding_changes/and_properties_changed_to_empty_array_then_child_removed.cs

@@ -14,7 +14,9 @@ public class and_properties_changed_to_empty_array_then_child_removed : given.a_
 
     void Establish()
     {
-        _itemsProperty = new PropertyPath("items");
+        // Create the array property path using AddArrayIndex to match runtime behavior
+        // At runtime, ChildrenPropertyPath is created with AddArrayIndex, resulting in format "[items]"
+        _itemsProperty = PropertyPath.Root.AddArrayIndex("items");
 
         // Create a PropertiesChanged that sets items to empty array
         var emptyArray = Array.Empty<object>();

Source/Infrastructure.Specs/Changes/for_Changeset/when_adding_changes/and_properties_changed_with_empty_array_and_other_properties_then_child_added.cs

@@ -15,7 +15,9 @@ public class and_properties_changed_with_empty_array_and_other_properties_then_c
 
     void Establish()
     {
-        _itemsProperty = new PropertyPath("items");
+        // Create the array property path using AddArrayIndex to match runtime behavior
+        // At runtime, ChildrenPropertyPath is created with AddArrayIndex, resulting in format "[items]"
+        _itemsProperty = PropertyPath.Root.AddArrayIndex("items");
         _nameProperty = new PropertyPath("name");
 
         // Create a PropertiesChanged that sets items to empty array and changes name

Source/Infrastructure/Changes/Changeset.cs

@@ -459,7 +459,7 @@ bool ShouldFilterPropertyDifference(PropertyDifference diff, HashSet<PropertyPat
             // Check if this array path matches any of the arrays with child operations
             foreach (var arrayPath in arraysWithChildOperations)
             {
-                if (diff.PropertyPath.Path.Equals(arrayPath.Path, StringComparison.Ordinal))
+                if (diff.PropertyPath.Path.Equals(arrayPath.LastSegment.Value, StringComparison.Ordinal))
                 {
                     return true;
                 }

Source/Kernel/Projections.Specs/for_KeyResolvers/when_identifying_read_model_key_from_parent_hierarchy_using_sink_lookup.cs

@@ -0,0 +1,123 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Cratis.Chronicle.Concepts.Events;
+using Cratis.Chronicle.Concepts.Identities;
+using Cratis.Chronicle.Concepts.Keys;
+using Cratis.Chronicle.Concepts.Projections;
+using Cratis.Chronicle.Dynamic;
+using Cratis.Chronicle.Properties;
+using Cratis.Chronicle.Storage.EventSequences;
+using Cratis.Chronicle.Storage.Sinks;
+using Cratis.Monads;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Cratis.Chronicle.Projections.for_KeyResolvers;
+
+public class when_identifying_read_model_key_from_parent_hierarchy_using_sink_lookup : Specification
+{
+    AppendedEvent _childEvent;
+    Key _result;
+    IProjection _parentProjection;
+    IProjection _childProjection;
+    IEventSequenceStorage _storage;
+    ISink _sink;
+    KeyResolvers _keyResolvers;
+
+    static EventType _parentEventType = new("5f4f4368-6989-4d9d-a84e-7393e0b41cfd", 1);
+    static EventType _childEventType = new("02405794-91e7-4e4f-8ad1-f043070ca297", 1);
+    const string RootKey = "root-key-123";
+    const string ParentKey = "parent-key-456";
+    const string ChildKey = "child-key-789";
+    const string ChildEventSourceId = "different-event-source-id";
+
+    PropertyPath _queriedChildPropertyPath;
+
+    void Establish()
+    {
+        _keyResolvers = new KeyResolvers(NullLogger<KeyResolvers>.Instance);
+
+        // Child event appended to a DIFFERENT EventSourceId than the parent
+        // This simulates the scenario where events are appended to a different stream
+        // but contain the parent key in their content
+        _childEvent = new(
+            new(
+                _childEventType,
+                EventSourceType.Default,
+                ChildEventSourceId, // Different from ParentKey
+                EventStreamType.All,
+                EventStreamId.Default,
+                1,
+                DateTimeOffset.UtcNow,
+                "123b8935-a1a4-410d-aace-e340d48f0aa0",
+                "41f18595-4748-4b01-88f7-4c0d0907aa90",
+                CorrelationId.New(),
+                [],
+                Identity.System),
+            new
+            {
+                parentId = ParentKey,
+                childId = ChildKey,
+                name = "Test Child"
+            }.AsExpandoObject());
+
+        _parentProjection = Substitute.For<IProjection>();
+        _parentProjection.EventTypes.Returns([_parentEventType]);
+        _parentProjection.OwnEventTypes.Returns([_parentEventType]);
+        _parentProjection.IdentifiedByProperty.Returns((PropertyPath)"id");
+        _parentProjection.Path.Returns((ProjectionPath)"configurations");
+        _parentProjection.ChildrenPropertyPath.Returns(PropertyPath.NotSet);
+        _parentProjection.HasParent.Returns(false);
+        _parentProjection.Parent.Returns((IProjection)null!);
+
+        _childProjection = Substitute.For<IProjection>();
+        _childProjection.HasParent.Returns(true);
+        _childProjection.Parent.Returns(_parentProjection);
+        _childProjection.ChildrenPropertyPath.Returns((PropertyPath)"hubs");
+        _childProjection.IdentifiedByProperty.Returns((PropertyPath)"hubId");
+        _childProjection.Path.Returns((ProjectionPath)"configurations -> hubs");
+
+        _storage = Substitute.For<IEventSequenceStorage>();
+        _sink = Substitute.For<ISink>();
+
+        // Parent event is NOT found by EventSourceId (returns empty)
+        // This forces the code to use sink lookup
+        _storage.TryGetLastInstanceOfAny(ParentKey, Arg.Any<IEnumerable<EventTypeId>>())
+            .Returns(Option<AppendedEvent>.None());
+
+        // Sink lookup returns the root key
+        // Capture the property path used in the query to verify it's correct
+        _sink.When(x => x.TryFindRootKeyByChildValue(Arg.Any<PropertyPath>(), ParentKey))
+            .Do(callInfo => _queriedChildPropertyPath = callInfo.ArgAt<PropertyPath>(0));
+
+        _sink.TryFindRootKeyByChildValue(Arg.Any<PropertyPath>(), ParentKey)
+            .Returns(new Option<Key>(new Key(RootKey, ArrayIndexers.NoIndexers)));
+
+        // Mock recursive resolution to return a simple key
+        _sink.TryFindRootKeyByChildValue(Arg.Any<PropertyPath>(), RootKey)
+            .Returns(Option<Key>.None());
+    }
+
+    async Task Because()
+    {
+        try
+        {
+            var keyResult = await _keyResolvers.FromParentHierarchy(
+                _childProjection,
+                _keyResolvers.FromEventValueProvider(EventValueProviders.EventContent("childId")),
+                _keyResolvers.FromEventValueProvider(EventValueProviders.EventContent("parentId")),
+                "hubId")(_storage, _sink, _childEvent);
+            _result = (keyResult as ResolvedKey)?.Key;
+        }
+        catch
+        {
+            // Ignore exceptions - we're only testing that the sink was called with the correct path
+        }
+    }
+
+    [Fact] void should_query_sink_with_child_projection_children_property_path() =>
+        _queriedChildPropertyPath.ShouldEqual((PropertyPath)"hubs.id");
+
+    [Fact] void should_not_query_sink_with_parent_projection_children_property_path() =>
+        _queriedChildPropertyPath.ShouldNotEqual((PropertyPath)"configurations.id");
+}

Source/Kernel/Projections/KeyResolvers.cs

@@ -196,7 +196,7 @@ public KeyResolver FromParentHierarchy(IProjection projection, KeyResolver keyRe
                             return KeyResolverResult.Deferred(deferredFuture);
                         }
 
-                        var childPropertyPath = parentProjection.ChildrenPropertyPath + parentIdentifiedByProperty;
+                        var childPropertyPath = projection.ChildrenPropertyPath + parentIdentifiedByProperty;
 
                         logger.FromParentHierarchyLookupBySink(childPropertyPath.Path, parentKey.Value?.ToString() ?? "null");