@cratis/chronicle 6.53.0 → 6.54.0

package/projections/for_ProjectionDefinitionCompiler/when_compiling_from_all_events.standard.spec.ts

@@ -61,26 +61,66 @@ describe('when compiling standard fromAllEvents without explicit event subscript
         should(getFromAllEventsMetadata(Alias.prototype, 'title') === undefined).be.true;
     });
 
-    it('should collect standard child and nested mappings in the root All without widening the subscription', () => {
+    it('should collect standard child and nested mappings on their owning levels without widening the subscription', () => {
         @eventType('standard-from-all-events-child-added')
         class Added { @field(String) id = ''; }
-        class Detail { @field(String) @fromAllEvents(undefined, 'sequenceNumber') sequence = ''; }
+        class Detail {
+            @field(String) @fromAllEvents(undefined, 'sequenceNumber') sequence = '';
+            @field(String) @fromAllEvents() label = '';
+        }
         class Child {
             @field(String) id = '';
             @field(String) @fromAllEvents('name') title = '';
+            @field(String) @fromEvery('everyName') @fromAll('aliasName') restricted = '';
             @field(Detail) @nested detail = new Detail();
         }
         class Derived extends Child {}
-        class Parent {
+        class Sibling extends Child { @field(String) @fromAllEvents('siblingName') override title = ''; }
+        class Group {
             @field(Array, { genericArguments: [Derived] }) @childrenFrom(Added, 'id') items: Derived[] = [];
         }
-        const { definition } = compileModelBound(Parent);
-        should(definition.All).deep.equal({
-            Properties: { title: 'name', sequence: '$eventContext(SequenceNumber)' }, IncludeChildren: true, AutoMap: 0
-        });
+        class Parent {
+            @field(Array, { genericArguments: [Group] }) @childrenFrom(Added, 'id') groups: Group[] = [];
+            @field(Array, { genericArguments: [Sibling] }) @childrenFrom(Added, 'id') siblings: Sibling[] = [];
+            @field(Detail) @nested detail = new Detail();
+        }
+        const { compiled, definition } = compileModelBound(Parent);
+        should(definition.All).deep.equal({ Properties: {}, IncludeChildren: false, AutoMap: 0 });
         should(definition.SubscribesToAllEvents === undefined).be.true;
-        should(definition.Children.items.All!.Properties).deep.equal({});
-        should(definition.Children.items.Nested.detail.All!.Properties).deep.equal({});
+        should(definition.Children.groups.All!.Properties).deep.equal({});
+        should(definition.Children.groups.Children.items.All!.Properties).deep.equal({ title: 'name', restricted: 'everyName' });
+        should(definition.Children.siblings.All!.Properties).deep.equal({ title: 'siblingName', restricted: 'everyName' });
+        const detailMappings = { sequence: '$eventContext(SequenceNumber)', label: 'label' };
+        should(definition.Children.groups.Children.items.Nested.detail.All!.Properties).deep.equal(detailMappings);
+        should(definition.Nested.detail.All!.Properties).deep.equal(detailMappings);
+        should(compiled.provenance.get(definition)).include.deep.members([
+            { contractPath: 'Children.groups.Children.items.All.Properties.restricted', declaration: '@fromEvery' },
+            { contractPath: 'Children.groups.Children.items.Nested.detail.All.Properties.sequence', declaration: '@fromAllEvents' }
+        ]);
+    });
+
+    it('should preserve independent same-named root and child mappings in either property order', () => {
+        @eventType('standard-all-same-name-added')
+        class Added { @field(String) id = ''; }
+        class Child {
+            @field(String) id = '';
+            @field(String) @fromEvery('ignored') @fromAllEvents('childName') title = '';
+            @field(String) @fromAllEvents('childOther') @fromEvery('ignored') other = '';
+        }
+        class RootFirst {
+            @field(String) @fromAllEvents('rootName') title = '';
+            @field(Array, { genericArguments: [Child] }) @childrenFrom(Added, 'id') items: Child[] = [];
+        }
+        class ChildFirst {
+            @field(Array, { genericArguments: [Child] }) @childrenFrom(Added, 'id') items: Child[] = [];
+            @field(String) @fromAllEvents('rootName') title = '';
+        }
+        for (const type of [RootFirst, ChildFirst]) {
+            const { definition } = compileModelBound(type);
+            should(definition.All!.Properties).deep.equal({ title: 'rootName' });
+            should(definition.Children.items.All!.Properties).deep.equal({ title: 'childName', other: 'childOther' });
+            should(definition.SubscribesToAllEvents).be.true;
+        }
     });
 
     it('should reject all-event scenarios before replay with the standard decorator declaration', () => {

package/projections/modelBound/childrenAndNestedBuilder.ts

@@ -234,12 +234,14 @@ function discoverIdentifiedBy(childType: Function | undefined, eventKey: string
  * `@childrenFrom`/`@nested` properties the child/nested type itself declares.
  * @param definition - The children definition being populated.
  * @param childType - The resolved child/nested type, when available.
- * @param collectSharedMapping - Collects member mappings into the root's shared All definition.
+ * @param path - The contract path of this child or nested definition.
+ * @param collectSharedMapping - Collects member mappings into their owning All definition.
  */
 function populateFromType(
     definition: ChildrenDefinitionLike,
     childType: Function | undefined,
-    collectSharedMapping?: (prototype: object, property: string) => void
+    path: string,
+    collectSharedMapping?: (prototype: object, property: string, all: ChildrenDefinitionLike['All'], path: string) => void
 ): void {
     if (!childType) {
         return;
@@ -281,8 +283,7 @@ function populateFromType(
 
     const prototype = childType.prototype;
     const properties = TypeIntrospector.getTrackedProperties(childType);
-    // Like .NET, collect this type's members before descending into its children.
-    for (const property of properties) collectSharedMapping?.(prototype, property);
+    for (const property of properties) collectSharedMapping?.(prototype, property, definition.All, `${path}.All`);
     for (const property of properties) {
         applyPropertyMappings(prototype, property, fromByEventType);
 
@@ -307,11 +308,11 @@ function populateFromType(
 
         const childrenFromList = getChildrenFromMetadata(prototype, property);
         if (childrenFromList.length > 0) {
-            definition.Children[property] = buildChildrenEntry(childType, property, childrenFromList, collectSharedMapping);
+            definition.Children[property] = buildChildrenEntry(childType, property, childrenFromList, collectSharedMapping, `${path}.Children.${property}`);
         }
 
         if (isNested(prototype, property)) {
-            definition.Nested[property] = buildNestedEntry(childType, property, collectSharedMapping);
+            definition.Nested[property] = buildNestedEntry(childType, property, collectSharedMapping, `${path}.Nested.${property}`);
         }
     }
 
@@ -325,14 +326,16 @@ function populateFromType(
  * @param type - The class declaring the property.
  * @param property - The property name.
  * @param metadataList - The `@childrenFrom` metadata entries declared on the property (one per creating event type).
- * @param collectSharedMapping - Collects member mappings into the root's shared All definition.
+ * @param collectSharedMapping - Collects member mappings into their owning All definition.
+ * @param path - The contract path of this children definition.
  * @returns The wire-shaped children definition.
  */
 export function buildChildrenEntry(
     type: Function,
     property: string,
     metadataList: ChildrenFromMetadata[],
-    collectSharedMapping?: (prototype: object, property: string) => void
+    collectSharedMapping?: (prototype: object, property: string, all: ChildrenDefinitionLike['All'], path: string) => void,
+    path = `Children.${property}`
 ): ChildrenDefinitionLike {
     const childType = resolveChildElementType(type, property);
     const definition = createEmptyChildrenDefinition(type, childType);
@@ -352,7 +355,7 @@ export function buildChildrenEntry(
         });
     }
 
-    populateFromType(definition, childType, collectSharedMapping);
+    populateFromType(definition, childType, path, collectSharedMapping);
 
     // For non-aggregate-only creating events, populate an unmapped child identifier from
     // the creating event's key. IdentifiedBy selects the child property; it is not itself
@@ -395,13 +398,15 @@ export function buildChildrenEntry(
  * Builds the `ChildrenDefinition` for a `@nested` single-object property.
  * @param type - The class declaring the property.
  * @param property - The property name.
- * @param collectSharedMapping - Collects member mappings into the root's shared All definition.
+ * @param collectSharedMapping - Collects member mappings into their owning All definition.
+ * @param path - The contract path of this nested definition.
  * @returns The wire-shaped nested definition.
  */
 export function buildNestedEntry(
     type: Function,
     property: string,
-    collectSharedMapping?: (prototype: object, property: string) => void
+    collectSharedMapping?: (prototype: object, property: string, all: ChildrenDefinitionLike['All'], path: string) => void,
+    path = `Nested.${property}`
 ): ChildrenDefinitionLike {
     const nestedType = resolveNestedType(type, property);
     const definition = createEmptyChildrenDefinition(type, nestedType);
@@ -414,6 +419,6 @@ export function buildNestedEntry(
         definition.RemovedWith.push({ Key: eventType, Value: { Key: '$eventSourceId', ParentKey: '' } });
     }
 
-    populateFromType(definition, nestedType, collectSharedMapping);
+    populateFromType(definition, nestedType, path, collectSharedMapping);
     return definition;
 }