@cratis/chronicle 6.32.0 → 6.33.0

package/testing/ReadModelScenario.childrenFrom.spec.ts

@@ -1,11 +1,13 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+import { readFileSync } from 'node:fs';
 import { chai, describe, it } from 'vitest';
 import { eventType } from '../events/eventTypeDecorator.js';
 import { childrenFrom } from '../projections/modelBound/childrenFrom.js';
 import { fromEvent } from '../projections/modelBound/fromEvent.js';
 import { setFrom } from '../projections/modelBound/setFrom.js';
+import { JsonSchemaGenerator } from '../schemas/JsonSchemaGenerator.js';
 import { ReadModelScenario, UnsupportedProjectionOperation } from './index.js';
 
 chai.should();
@@ -27,6 +29,18 @@ class ScenarioOrder {
 childrenFrom(ScenarioItemAdded, { childType: ScenarioItem, key: 'itemId' })(ScenarioOrder.prototype, 'items');
 fromEvent(ScenarioItemAdded)(ScenarioOrder);
 
+class ScenarioKeyedItem {
+    itemId = '';
+    name = '';
+}
+
+class ScenarioKeyedOrder {
+    id = '';
+    items: ScenarioKeyedItem[] = [];
+}
+childrenFrom(ScenarioItemAdded, { childType: ScenarioKeyedItem, key: 'itemId' })(ScenarioKeyedOrder.prototype, 'items');
+fromEvent(ScenarioItemAdded)(ScenarioKeyedOrder);
+
 class ScenarioNamedItem {
     id = '';
     name = '';
@@ -40,17 +54,70 @@ class ScenarioNamedOrder {
 childrenFrom(ScenarioItemAdded, { childType: ScenarioNamedItem, key: 'itemId' })(ScenarioNamedOrder.prototype, 'items');
 fromEvent(ScenarioItemAdded)(ScenarioNamedOrder);
 
+class ScenarioUnknownOrder {
+    id = '';
+    items: ScenarioItem[] = [];
+}
+childrenFrom(ScenarioItemAdded, { key: 'itemId', identifiedBy: 'id' })(ScenarioUnknownOrder.prototype, 'items');
+fromEvent(ScenarioItemAdded)(ScenarioUnknownOrder);
+
+class ScenarioUnresolvedItem {
+    id!: string;
+    name!: string;
+}
+
+class ScenarioUnresolvedOrder {
+    id = '';
+    items: ScenarioUnresolvedItem[] = [];
+}
+childrenFrom(ScenarioItemAdded, { childType: ScenarioUnresolvedItem, key: 'itemId', identifiedBy: 'id' })(ScenarioUnresolvedOrder.prototype, 'items');
+fromEvent(ScenarioItemAdded)(ScenarioUnresolvedOrder);
+
 const artifacts = { eventTypes: [ScenarioItemAdded], reducers: [], projections: [] };
 
 describe('when a read model scenario evaluates keyed children from the options form', () => {
-    it('should add one child per key and update an existing child in place (children-untyped-items)', async () => {
+    it('should add one child per key and update an existing child in place (children-typed-items)', async () => {
         const scenario = new ReadModelScenario(ScenarioOrder, artifacts);
         scenario.given.forEventSource('order-1').events(
             new ScenarioItemAdded('a', 'first'), new ScenarioItemAdded('b', 'second'), new ScenarioItemAdded('a', 'again'));
         const order = await scenario.instanceForEventSourceId('order-1');
         order!.id.should.equal('order-1');
-        // The kernel's AutoMap is schema-driven, and legacy decorators register an untyped child item schema.
-        order!.items.map(item => ({ id: item.id, name: item.name })).should.deep.equal([{ id: 'a', name: '' }, { id: 'b', name: '' }]);
+        // The explicit child type registers a typed item schema, so AutoMap preserves the event's name.
+        order!.items.map(item => ({ id: item.id, name: item.name })).should.deep.equal([{ id: 'a', name: 'again' }, { id: 'b', name: 'second' }]);
+    });
+
+    it('should register the same typed items schema as the oracle fixture', () => {
+        const fixture = JSON.parse(readFileSync(new URL('./projections/fixtures/children-typed-items.json', import.meta.url), 'utf8'));
+        JsonSchemaGenerator.generate(ScenarioOrder).properties!.items.should.deep.equal(fixture.readModel.schema.properties.items);
+    });
+
+    it('should add and update typed legacy children whose discovered identifier equals the event key (children-identifier-equals-key)', async () => {
+        const fixture = JSON.parse(readFileSync(new URL('./projections/fixtures/children-identifier-equals-key.json', import.meta.url), 'utf8'));
+        JsonSchemaGenerator.generate(ScenarioKeyedOrder).properties!.items.should.deep.equal(fixture.readModel.schema.properties.items);
+        const scenario = new ReadModelScenario(ScenarioKeyedOrder, artifacts);
+        for (let step = 0; step < 3; step++) {
+            const { itemId, name } = fixture.events[step].content;
+            scenario.given.forEventSource('order-1').events(new ScenarioItemAdded(itemId, name));
+            const order = await scenario.instanceForEventSourceId('order-1');
+            order!.should.deep.equal(fixture.expected[step].publicRead['order-1']);
+        }
+    });
+
+    it('should retain only the identifier when the child type is unknown (children-untyped-items)', async () => {
+        const scenario = new ReadModelScenario(ScenarioUnknownOrder, artifacts);
+        scenario.given.forEventSource('order-1').events(new ScenarioItemAdded('a', 'first'));
+        const order = await scenario.instanceForEventSourceId('order-1');
+        order!.items.should.deep.equal([{ id: 'a' }]);
+    });
+
+    it('should retain only the identifier when the declared child members have no runtime types (children-untyped-items)', async () => {
+        const fixture = JSON.parse(readFileSync(new URL('./projections/fixtures/children-untyped-items.json', import.meta.url), 'utf8'));
+        JsonSchemaGenerator.generate(ScenarioUnresolvedOrder).properties!.items.should.deep.equal(fixture.readModel.schema.properties.items);
+        const scenario = new ReadModelScenario(ScenarioUnresolvedOrder, artifacts);
+        scenario.given.forEventSource('order-1').events(
+            new ScenarioItemAdded('a', 'first'), new ScenarioItemAdded('b', 'second'), new ScenarioItemAdded('a', 'again'));
+        const order = await scenario.instanceForEventSourceId('order-1');
+        order!.items.map(item => ({ id: item.id, name: item.name })).should.deep.equal([{ id: 'a', name: undefined }, { id: 'b', name: undefined }]);
     });
 
     it('should reject explicit child property mappings', () => {

package/testing/projections/ProjectionChildrenCapabilities.ts

@@ -30,7 +30,8 @@ const kernelBacked = 'require a kernel-backed test (ChronicleKernelScenario / li
 
 /**
  * Validates one level of children collections against the packaged-kernel fixtures
- * (`children-from-keyed`, `children-identified-removed`, `children-untyped-items`).
+ * (`children-from-keyed`, `children-identified-removed`, `children-typed-items`,
+ * `children-untyped-items`, `children-identifier-equals-key`).
  */
 export class ProjectionChildrenCapabilities {
     /**
@@ -109,7 +110,13 @@ export class ProjectionChildrenCapabilities {
                     const candidates = Object.keys(eventSchema.properties ?? {}).filter(source => source.toLowerCase() === destination.toLowerCase());
                     if (!candidates.length) continue;
                     const mappingPath = `${path}.AutoMap.${destination}`;
-                    if (destination === identifiedBy) reject(mappingPath, `AutoMap into the child identifier ${kernelBacked}`);
+                    if (destination === identifiedBy) {
+                        if (candidates.length !== 1 || candidates[0] !== entry.Value.Key) {
+                            reject(mappingPath, `AutoMap into the child identifier ${kernelBacked}`);
+                        }
+                        // Changeset.AddChild initializes the identifier from this same key.
+                        continue;
+                    }
                     if (candidates.length > 1) reject(mappingPath, `inferred AutoMap source is ambiguous: ${candidates.join(', ')}`);
                     context.checkMapping(items!, eventSchema, destination, candidates[0], mappingPath);
                 }

package/testing/projections/for_ProjectionCapabilities/when_rejecting_unsupported_children_operations.spec.ts

@@ -8,6 +8,7 @@ import { chai, describe, it } from 'vitest';
 import { eventType } from '../../../events/eventTypeDecorator.js';
 import type { ChildrenDefinitionLike } from '../../../projections/modelBound/childrenAndNestedBuilder.js';
 import { childrenFrom } from '../../../projections/modelBound/childrenFrom.js';
+import type { JsonSchema } from '../../../schemas/JsonSchema.js';
 import { ProjectionCapabilities } from '../ProjectionCapabilities.js';
 import { UnsupportedProjectionOperation } from '../UnsupportedProjectionOperation.js';
 import { Changed } from './given/Changed.js';
@@ -32,12 +33,45 @@ function compileChildren() {
     return { ...result, wire, child: wire.Children.labels };
 }
 
+function compileTypedChildren() {
+    const result = compileChildren();
+    result.child.IdentifiedBy = 'itemId';
+    result.child.From[0].Value.Properties = {};
+    const schema = JSON.parse(result.compiled.readModels[0].Schema) as JsonSchema;
+    schema.properties!.labels.items = {
+        type: 'object', properties: { itemId: { type: 'string' }, name: { type: 'string' } }
+    };
+    result.compiled.readModels[0].Schema = JSON.stringify(schema);
+    return result;
+}
+
 describe('when rejecting unsupported children operations before any event is seeded', () => {
     it('should accept the fixture-backed keyed children shape', () => {
         const { compiled, definition } = compileChildren();
         (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
     });
 
+    it('should accept AutoMap into a typed child identifier from the entry key alone', () => {
+        const { compiled, definition } = compileTypedChildren();
+        (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
+    });
+
+    it('should reject AutoMap into a typed child identifier from a property other than the entry key', () => {
+        const { compiled, definition, child } = compileTypedChildren();
+        child.From[0].Value.Key = 'name';
+        (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation)
+            .with.property('message').that.includes('Children.labels.From[capability-child-added:1].AutoMap.itemId')
+            .and.includes('AutoMap into the child identifier');
+    });
+
+    it('should reject ambiguous AutoMap into a typed child identifier even if one candidate is the entry key', () => {
+        const { compiled, definition } = compileTypedChildren();
+        compiled.eventSchemas.get(definition)!.get('capability-child-added:1:0')!.schema.properties!.ItemId = { type: 'string' };
+        (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation)
+            .with.property('message').that.includes('Children.labels.From[capability-child-added:1].AutoMap.itemId')
+            .and.includes('AutoMap into the child identifier');
+    });
+
     const cases: Array<{ name: string; change: (child: ChildrenDefinitionLike, wire: Wire) => void; path: string; reason: string }> = [
         { name: 'a join inside children', change: child => { child.Join = [{}]; }, path: 'Children.labels.Join', reason: 'joins require a kernel-backed test' },
         { name: 'nested children collections', change: child => { child.Children = { inner: child }; }, path: 'Children.labels.Children', reason: 'nested children collections' },