@cratis/chronicle 6.17.0 → 6.18.0

package/projections/modelBound/childrenAndNestedBuilder.ts

@@ -48,6 +48,8 @@ export interface ChildrenDefinitionLike {
     NoAutoMapProperties: string[];
 }
 
+const aggregateExpressions = ['$count', '$increment', '$decrement', '$add', '$subtract'];
+
 /**
  * Resolves the contract event type for a decorated event constructor.
  * @param eventTypeConstructor - The event class constructor.
@@ -209,23 +211,20 @@ export function resolveNestedType(type: Function, property: string): Function |
 
 /**
  * Discovers the child model property used to identify instances, by convention: a property
- * named `id` (case-insensitive), matching the C# client's fallback once no `[Key]` attribute
- * is present (TypeScript has no `[Key]` decorator equivalent).
+ * named `id` (case-insensitive), or a property matching the event key when no id is found.
+ * TypeScript has no `[Key]` decorator equivalent.
  * @param childType - The child/nested model type, when resolvable.
+ * @param eventKey - The configured event key, when present.
  * @returns The discovered property name, or undefined when no convention match is found.
  */
-function discoverIdentifiedBy(childType: Function | undefined): string | undefined {
+function discoverIdentifiedBy(childType: Function | undefined, eventKey: string | undefined): string | undefined {
     if (!childType) {
         return undefined;
     }
 
-    for (const name of TypeIntrospector.getMembers(childType).keys()) {
-        if (name.toLowerCase() === 'id') {
-            return name;
-        }
-    }
-
-    return undefined;
+    const members = [...TypeIntrospector.getMembers(childType).keys()];
+    return members.find(name => name.toLowerCase() === 'id') ??
+        (eventKey !== undefined ? members.find(name => name.toLowerCase() === eventKey.toLowerCase()) : undefined);
 }
 
 /**
@@ -325,7 +324,7 @@ export function buildChildrenEntry(type: Function, property: string, metadataLis
     const definition = createEmptyChildrenDefinition(type, childType);
 
     const explicitIdentifiedBy = metadataList.find(metadata => metadata.identifiedBy)?.identifiedBy;
-    definition.IdentifiedBy = explicitIdentifiedBy ?? discoverIdentifiedBy(childType) ?? '$eventSourceId';
+    definition.IdentifiedBy = explicitIdentifiedBy ?? discoverIdentifiedBy(childType, metadataList[0]?.key) ?? '$eventSourceId';
 
     for (const metadata of metadataList) {
         const eventType = toContractEventType(metadata.eventType);
@@ -340,6 +339,41 @@ export function buildChildrenEntry(type: Function, property: string, metadataLis
     }
 
     populateFromType(definition, childType);
+
+    // 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
+    // a property mapping. TypeScript has no [Key] decorator, so an explicit identifiedBy
+    // plays the same role as a discovered id for this default.
+    const identifier = definition.IdentifiedBy;
+    if (definition.AutoMap === AutoMap.Enabled && identifier !== '$eventSourceId') {
+        const prototype = childType?.prototype;
+        const hasExplicitMapping = prototype !== undefined && (
+            getSetFromMetadata(prototype, identifier).length > 0 ||
+            getSetFromContextMetadata(prototype, identifier).length > 0 ||
+            getSetValueMetadata(prototype, identifier).length > 0 ||
+            getAddFromMetadata(prototype, identifier).length > 0 ||
+            getSubtractFromMetadata(prototype, identifier).length > 0);
+        if (!hasExplicitMapping) {
+            for (const metadata of metadataList) {
+                const entry = definition.From.find(candidate => getEventTypeMapKey(candidate.Key) === getEventTypeMapKey(toContractEventType(metadata.eventType)))!;
+                const mappings = Object.values(entry.Value.Properties);
+                // Preserve the kernel's aggregate-only AutoMap exemption: Changeset.AddChild already
+                // initializes the child identifier from the resolved key before applying property mappers.
+                if (mappings.length > 0 && mappings.every(expression =>
+                    aggregateExpressions.some(aggregate => expression.startsWith(aggregate)))) {
+                    continue;
+                }
+                // Child property mappings may replace the creating key (for example, a constant-key count).
+                const key = entry.Value.Key;
+                // When an event property is also the identifier, AutoMap can fill it directly.
+                if (key.toLowerCase() !== identifier.toLowerCase() && !(identifier in entry.Value.Properties)) {
+                    entry.Value.Properties[identifier] = key === '$eventSourceId'
+                        ? eventContextPropertyExpression('eventSourceId')
+                        : key;
+                }
+            }
+        }
+    }
     return definition;
 }