@cratis/chronicle 6.43.0 → 6.44.0

package/projections/for_ProjectionDefinitionCompiler/when_compiling_from_all_events.spec.ts

@@ -0,0 +1,235 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { field } from '@cratis/fundamentals';
+import { beforeEach, chai, describe, it } from 'vitest';
+import { fromAllEvents, getFromAllEventsMetadata } from '../../index.js';
+import { eventType } from '../../events/eventTypeDecorator.js';
+import { childrenFrom } from '../modelBound/childrenFrom.js';
+import { fromAll, getFromAllMetadata } from '../modelBound/fromAll.js';
+import { fromEvery, getFromEveryMetadata } from '../modelBound/fromEvery.js';
+import { fromEvent } from '../modelBound/fromEvent.js';
+import { isModelBoundProjection } from '../modelBound/isModelBoundProjection.js';
+import { nested } from '../modelBound/nested.js';
+import { TypeIntrospector } from '../../types/index.js';
+import { ReadModelScenario } from '../../testing/ReadModelScenario.js';
+import { UnsupportedProjectionOperation } from '../../testing/projections/UnsupportedProjectionOperation.js';
+import { compileModelBound } from './given/compile_model_bound.js';
+
+chai.should();
+
+class Model {
+    id = '';
+    title = '';
+    source = '';
+    sequence = '';
+}
+for (const property of ['id', 'title', 'source', 'sequence']) field(String)(Model.prototype, property);
+
+function discoveredByExistingReaders(type: Function): boolean {
+    return TypeIntrospector.getTrackedProperties(type).some(property =>
+        !!getFromEveryMetadata(type.prototype, property) || !!getFromAllMetadata(type.prototype, property));
+}
+
+describe('when compiling legacy fromAllEvents without explicit event subscriptions', () => {
+    let result: ReturnType<typeof compileModelBound>;
+    beforeEach(() => {
+        class Candidate extends Model {}
+        fromAllEvents()(Candidate.prototype, 'title');
+        fromAllEvents(undefined, 'sequenceNumber')(Candidate.prototype, 'sequence');
+        fromEvery(undefined, 'eventSourceId')(Candidate.prototype, 'source');
+        result = compileModelBound(Candidate);
+    });
+    it('should subscribe to every event without expanding a known event list', () => {
+        result.definition.SubscribesToAllEvents.should.be.true;
+        result.definition.From.should.deep.equal([]);
+        result.definition.FromEvery.should.deep.equal([]);
+    });
+    it('should merge content and context mappings into All including children', () => {
+        result.definition.All!.should.deep.equal({ Properties: {
+            title: 'title', sequence: '$eventContext(SequenceNumber)', source: '$eventContext(EventSourceId)'
+        }, IncludeChildren: true, AutoMap: 0 });
+    });
+    it('should preserve the distinct decorator in subscription and mapping diagnostics', () => {
+        result.compiled.provenance.get(result.definition)!.should.include.deep.members([
+            { contractPath: 'SubscribesToAllEvents', declaration: '@fromAllEvents' },
+            { contractPath: 'All', declaration: '@fromAllEvents' },
+            { contractPath: 'All.Properties.title', declaration: '@fromAllEvents' },
+            { contractPath: 'All.Properties.source', declaration: '@fromEvery' }
+        ]);
+    });
+});
+
+describe('when using legacy fromAllEvents in a read-model scenario', () => {
+    it('should reject the subscription before events can be seeded', () => {
+        class Candidate extends Model {}
+        fromAllEvents('title')(Candidate.prototype, 'title');
+        (() => new ReadModelScenario(Candidate, { readModels: [Candidate], eventTypes: [], projections: [], reducers: [] }))
+            .should.throw(UnsupportedProjectionOperation, 'SubscribesToAllEvents (@fromAllEvents)');
+    });
+});
+
+describe('when discovering and inheriting legacy fromAllEvents metadata', () => {
+    class AllModel extends Model {}
+    fromAllEvents('name')(AllModel.prototype, 'title');
+    class Derived extends AllModel {}
+    class Sibling extends Model {}
+    fromAll('restrictedName')(Sibling.prototype, 'title');
+
+    it('should discover a model using only fromAllEvents with Arc style existing readers', () => {
+        discoveredByExistingReaders(AllModel).should.be.true;
+        isModelBoundProjection(AllModel).should.be.true;
+        getFromAllMetadata(AllModel.prototype, 'title')!.should.deep.equal({ property: 'name', contextProperty: undefined });
+        (getFromEveryMetadata(AllModel.prototype, 'title') === undefined).should.be.true;
+    });
+    it('should inherit discovery and the subscription without affecting a sibling', () => {
+        discoveredByExistingReaders(Derived).should.be.true;
+        compileModelBound(Derived).definition.SubscribesToAllEvents.should.be.true;
+        compileModelBound(Derived).definition.All!.should.deep.equal(compileModelBound(AllModel).definition.All);
+        (compileModelBound(Sibling).definition.SubscribesToAllEvents === undefined).should.be.true;
+        (getFromAllEventsMetadata(Sibling.prototype, 'title') === undefined).should.be.true;
+    });
+    it('should keep derived annotations independent from the base', () => {
+        class Override extends AllModel {}
+        fromAllEvents('derivedName')(Override.prototype, 'title');
+        compileModelBound(Override).definition.All!.Properties.title.should.equal('derivedName');
+        compileModelBound(AllModel).definition.All!.Properties.title.should.equal('name');
+    });
+});
+
+describe('when compiling fromAllEvents on a child model', () => {
+    class Child { id = ''; title = ''; }
+    field(String)(Child.prototype, 'id');
+    field(String)(Child.prototype, 'title');
+    fromAllEvents('name')(Child.prototype, 'title');
+    class Added { id = ''; name = ''; }
+    eventType('from-all-events-child-added')(Added);
+    field(String)(Added.prototype, 'id');
+    field(String)(Added.prototype, 'name');
+    class Parent extends Model { items: Child[] = []; }
+    field(Array, { enumerable: true, genericArguments: [Child] })(Parent.prototype, 'items');
+    childrenFrom(Added, 'id')(Parent.prototype, 'items');
+
+    it('should not widen the root subscription from child metadata', () => {
+        const { definition } = compileModelBound(Parent);
+        (definition.SubscribesToAllEvents === undefined).should.be.true;
+        ('SubscribesToAllEvents' in definition.Children.items).should.be.false;
+    });
+    it('should collect the child mapping by bare name in the root All without subscribing to all events', () => {
+        const { compiled, definition } = compileModelBound(Parent);
+        definition.All!.should.deep.equal({ Properties: { title: 'name' }, IncludeChildren: true, AutoMap: 0 });
+        definition.Children.items.All!.Properties.should.deep.equal({});
+        compiled.provenance.get(definition)!.should.include.deep.members([
+            { contractPath: 'All', declaration: '@fromAllEvents' },
+            { contractPath: 'All.Properties.title', declaration: '@fromAllEvents' }
+        ]);
+    });
+    it('should emit the subscription only at the root when the parent opts in', () => {
+        class AllParent extends Parent {}
+        fromAllEvents(undefined, 'eventSourceId')(AllParent.prototype, 'source');
+        const { definition } = compileModelBound(AllParent);
+        definition.SubscribesToAllEvents.should.be.true;
+        definition.All!.should.deep.equal({
+            Properties: { source: '$eventContext(EventSourceId)', title: 'name' }, IncludeChildren: true, AutoMap: 0
+        });
+        ('SubscribesToAllEvents' in definition.Children.items).should.be.false;
+    });
+    it('should share one bare-name mapping when a later child member shadows a root member', () => {
+        class AllParent extends Model { items: Child[] = []; }
+        fromAllEvents('rootName')(AllParent.prototype, 'title');
+        field(Array, { genericArguments: [Child] })(AllParent.prototype, 'items');
+        childrenFrom(Added, 'id')(AllParent.prototype, 'items');
+        compileModelBound(AllParent).definition.All!.Properties.should.deep.equal({ title: 'name' });
+    });
+});
+
+describe('when compiling fromAllEvents on nested and inherited child models', () => {
+    class Detail { label = ''; sequence = ''; }
+    field(String)(Detail.prototype, 'label');
+    field(String)(Detail.prototype, 'sequence');
+    fromAllEvents()(Detail.prototype, 'label');
+    fromAllEvents(undefined, 'sequenceNumber')(Detail.prototype, 'sequence');
+    class Added { id = ''; }
+    eventType('from-all-events-nested-child-added')(Added);
+    field(String)(Added.prototype, 'id');
+    class Child { id = ''; title = ''; ignored = ''; detail = new Detail(); }
+    field(String)(Child.prototype, 'id');
+    field(String)(Child.prototype, 'title');
+    field(String)(Child.prototype, 'ignored');
+    field(Detail)(Child.prototype, 'detail');
+    fromAllEvents('name')(Child.prototype, 'title');
+    fromEvery('ignoredEvery')(Child.prototype, 'ignored');
+    fromAll('ignoredAlias')(Child.prototype, 'ignored');
+    nested(Child.prototype, 'detail');
+    class InheritedChild extends Child {}
+    class Group { children: InheritedChild[] = []; }
+    field(Array, { genericArguments: [InheritedChild] })(Group.prototype, 'children');
+    childrenFrom(Added, 'id')(Group.prototype, 'children');
+    class Parent { groups: Group[] = []; detail = new Detail(); }
+    field(Array, { genericArguments: [Group] })(Parent.prototype, 'groups');
+    childrenFrom(Added, 'id')(Parent.prototype, 'groups');
+    field(Detail)(Parent.prototype, 'detail');
+    nested(Parent.prototype, 'detail');
+
+    it('should collect grandchild and nested mappings into the root without path prefixes or legacy child mappings', () => {
+        const { definition } = compileModelBound(Parent);
+        definition.All!.should.deep.equal({
+            Properties: { title: 'name', label: 'label', sequence: '$eventContext(SequenceNumber)' },
+            IncludeChildren: true, AutoMap: 0
+        });
+        (definition.SubscribesToAllEvents === undefined).should.be.true;
+        definition.Children.groups.Children.children.All!.Properties.should.deep.equal({});
+        definition.Children.groups.Children.children.Nested.detail.All!.Properties.should.deep.equal({});
+        definition.Nested.detail.All!.Properties.should.deep.equal({});
+    });
+    it('should collect a nested-only mapping without widening the root subscription', () => {
+        class NestedOnly { detail = new Detail(); }
+        fromEvent(Added)(NestedOnly);
+        field(Detail)(NestedOnly.prototype, 'detail');
+        nested(NestedOnly.prototype, 'detail');
+        const { definition } = compileModelBound(NestedOnly);
+        definition.All!.should.deep.equal({
+            Properties: { label: 'label', sequence: '$eventContext(SequenceNumber)' }, IncludeChildren: true, AutoMap: 0
+        });
+        (definition.SubscribesToAllEvents === undefined).should.be.true;
+        ('SubscribesToAllEvents' in definition.Nested.detail).should.be.false;
+    });
+});
+
+describe('when opting into fromAllEvents alongside inherited restricted mappings', () => {
+    it('should promote inherited fromEvery and fromAll mappings into the same shared All block', () => {
+        class Restricted extends Model {}
+        fromEvery(undefined, 'eventSourceId')(Restricted.prototype, 'source');
+        fromAll(undefined, 'sequenceNumber')(Restricted.prototype, 'sequence');
+        class AllModel extends Restricted {}
+        fromAllEvents('name')(AllModel.prototype, 'title');
+        const { definition } = compileModelBound(AllModel);
+        definition.SubscribesToAllEvents.should.be.true;
+        definition.All!.should.deep.equal({
+            Properties: { title: 'name', source: '$eventContext(EventSourceId)', sequence: '$eventContext(SequenceNumber)' },
+            IncludeChildren: true, AutoMap: 0
+        });
+        compileModelBound(Restricted).definition.All!.IncludeChildren.should.be.false;
+    });
+});
+
+for (const allEventsFirst of [true, false]) {
+    describe(`when all shared mapping decorators target one legacy property with fromAllEvents ${allEventsFirst ? 'first' : 'last'}`, () => {
+        it('should prefer the explicit subscription without overwriting compatibility metadata', () => {
+            class Candidate extends Model {}
+            if (allEventsFirst) fromAllEvents('newName')(Candidate.prototype, 'title');
+            fromEvery('everyName')(Candidate.prototype, 'title');
+            fromAll('aliasName')(Candidate.prototype, 'title');
+            if (!allEventsFirst) fromAllEvents('newName')(Candidate.prototype, 'title');
+            const { compiled, definition } = compileModelBound(Candidate);
+            definition.SubscribesToAllEvents.should.be.true;
+            definition.All!.Properties.title.should.equal('newName');
+            getFromAllMetadata(Candidate.prototype, 'title')!.property!.should.equal('aliasName');
+            getFromEveryMetadata(Candidate.prototype, 'title')!.property!.should.equal('everyName');
+            compiled.provenance.get(definition)!.should.include.deep.members([
+                { contractPath: 'All.Properties.title', declaration: '@fromAllEvents' }
+            ]);
+        });
+    });
+}

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

@@ -0,0 +1,107 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { field } from '@cratis/fundamentals';
+import { chai, describe, it, type Assertion } from 'vitest';
+import { fromAllEvents, getFromAllEventsMetadata, fromAll, getFromAllMetadata, fromEvery, getFromEveryMetadata, childrenFrom, nested } from '../index.js';
+import { eventType } from '../../events/eventTypeDecorator.js';
+import { TypeIntrospector } from '../../types/index.js';
+import { ReadModelScenario } from '../../testing/ReadModelScenario.js';
+import { UnsupportedProjectionOperation } from '../../testing/projections/UnsupportedProjectionOperation.js';
+import { compileModelBound } from './given/compile_model_bound.js';
+
+chai.should();
+function should(value: unknown): Assertion { return (value as { should: Assertion }).should; }
+
+class AllModel {
+    @field(String) id = '';
+    @field(String) @fromAllEvents('name') title = '';
+    @field(String) @fromAllEvents(undefined, 'sequenceNumber') sequence = '';
+    @field(String) @fromEvery(undefined, 'eventSourceId') source = '';
+    constructor() { throw new Error('Model discovery must not construct the model'); }
+}
+
+describe('when compiling standard fromAllEvents without explicit event subscriptions', () => {
+    it('should emit the subscription and shared mappings without constructing the model', () => {
+        const { definition } = compileModelBound(AllModel);
+        should(definition.SubscribesToAllEvents).be.true;
+        should(definition.From).deep.equal([]);
+        should(definition.FromEvery).deep.equal([]);
+        should(definition.All).deep.equal({ Properties: {
+            title: 'name', sequence: '$eventContext(SequenceNumber)', source: '$eventContext(EventSourceId)'
+        }, IncludeChildren: true, AutoMap: 0 });
+    });
+
+    it('should discover a model using only fromAllEvents through existing Arc style readers', () => {
+        class OnlyAll {
+            @field(String) @fromAllEvents() title = '';
+            constructor() { throw new Error('Discovery must not construct the model'); }
+        }
+        class Derived extends OnlyAll {}
+        for (const type of [OnlyAll, Derived]) {
+            should(TypeIntrospector.getTrackedProperties(type).some(property =>
+                !!getFromEveryMetadata(type.prototype, property) || !!getFromAllMetadata(type.prototype, property))).be.true;
+            should(getFromAllMetadata(type.prototype, 'title')).deep.equal({ property: undefined, contextProperty: undefined });
+            should(getFromEveryMetadata(type.prototype, 'title') === undefined).be.true;
+            should(compileModelBound(type).definition.SubscribesToAllEvents).be.true;
+        }
+    });
+
+    it('should inherit and override mappings without leaking the subscription to a sibling', () => {
+        class Base { @field(String) id = ''; }
+        class All extends Base { @field(String) @fromAllEvents('name') title = ''; }
+        class Derived extends All {}
+        class Override extends All { @field(String) @fromAllEvents('derivedName') override title = ''; }
+        class Alias extends Base { @field(String) @fromAll('name') title = ''; }
+        should(compileModelBound(Derived).definition.SubscribesToAllEvents).be.true;
+        should(compileModelBound(Derived).definition.All).deep.equal(compileModelBound(All).definition.All);
+        should(compileModelBound(Override).definition.All!.Properties.title).equal('derivedName');
+        should(compileModelBound(All).definition.All!.Properties.title).equal('name');
+        should(compileModelBound(Alias).definition.SubscribesToAllEvents === undefined).be.true;
+        should(getFromAllEventsMetadata(Alias.prototype, 'title') === undefined).be.true;
+    });
+
+    it('should collect standard child and nested mappings in the root All 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 Child {
+            @field(String) id = '';
+            @field(String) @fromAllEvents('name') title = '';
+            @field(Detail) @nested detail = new Detail();
+        }
+        class Derived extends Child {}
+        class Parent {
+            @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
+        });
+        should(definition.SubscribesToAllEvents === undefined).be.true;
+        should(definition.Children.items.All!.Properties).deep.equal({});
+        should(definition.Children.items.Nested.detail.All!.Properties).deep.equal({});
+    });
+
+    it('should reject all-event scenarios before replay with the standard decorator declaration', () => {
+        should(() => new ReadModelScenario(AllModel, { readModels: [AllModel], eventTypes: [], projections: [], reducers: [] }))
+            .throw(UnsupportedProjectionOperation, 'SubscribesToAllEvents (@fromAllEvents)');
+    });
+
+    it('should prefer fromAllEvents in either decorator order without changing the alias metadata', () => {
+        class Both {
+            @field(String) id = '';
+            @field(String) @fromEvery('everyName') @fromAll('aliasName') @fromAllEvents('newName') title = '';
+            @field(String) @fromAllEvents('otherName') @fromAll('aliasName') @fromEvery('everyName') other = '';
+        }
+        const { compiled, definition } = compileModelBound(Both);
+        should(definition.SubscribesToAllEvents).be.true;
+        should(definition.All!.Properties).deep.equal({ title: 'newName', other: 'otherName' });
+        should(getFromAllMetadata(Both.prototype, 'title')!.property).equal('aliasName');
+        should(getFromEveryMetadata(Both.prototype, 'title')!.property).equal('everyName');
+        should(compiled.provenance.get(definition)).include.deep.members([
+            { contractPath: 'SubscribesToAllEvents', declaration: '@fromAllEvents' },
+            { contractPath: 'All.Properties.title', declaration: '@fromAllEvents' }
+        ]);
+    });
+});

package/projections/modelBound/FromAllEventsMetadata.ts

@@ -0,0 +1,10 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/** Metadata stored by the fromAllEvents property decorator. */
+export interface FromAllEventsMetadata {
+    /** The event property name to read the value from. */
+    readonly property?: string;
+    /** The event context property name to read the value from. */
+    readonly contextProperty?: string;
+}

package/projections/modelBound/childrenAndNestedBuilder.ts

@@ -234,8 +234,13 @@ 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.
  */
-function populateFromType(definition: ChildrenDefinitionLike, childType: Function | undefined): void {
+function populateFromType(
+    definition: ChildrenDefinitionLike,
+    childType: Function | undefined,
+    collectSharedMapping?: (prototype: object, property: string) => void
+): void {
     if (!childType) {
         return;
     }
@@ -275,7 +280,10 @@ function populateFromType(definition: ChildrenDefinitionLike, childType: Functio
     }
 
     const prototype = childType.prototype;
-    for (const property of TypeIntrospector.getTrackedProperties(childType)) {
+    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) {
         applyPropertyMappings(prototype, property, fromByEventType);
 
         // A clear on the member carrying @nested removes that nested object; a clear on
@@ -299,11 +307,11 @@ function populateFromType(definition: ChildrenDefinitionLike, childType: Functio
 
         const childrenFromList = getChildrenFromMetadata(prototype, property);
         if (childrenFromList.length > 0) {
-            definition.Children[property] = buildChildrenEntry(childType, property, childrenFromList);
+            definition.Children[property] = buildChildrenEntry(childType, property, childrenFromList, collectSharedMapping);
         }
 
         if (isNested(prototype, property)) {
-            definition.Nested[property] = buildNestedEntry(childType, property);
+            definition.Nested[property] = buildNestedEntry(childType, property, collectSharedMapping);
         }
     }
 
@@ -317,9 +325,15 @@ function populateFromType(definition: ChildrenDefinitionLike, childType: Functio
  * @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.
  * @returns The wire-shaped children definition.
  */
-export function buildChildrenEntry(type: Function, property: string, metadataList: ChildrenFromMetadata[]): ChildrenDefinitionLike {
+export function buildChildrenEntry(
+    type: Function,
+    property: string,
+    metadataList: ChildrenFromMetadata[],
+    collectSharedMapping?: (prototype: object, property: string) => void
+): ChildrenDefinitionLike {
     const childType = resolveChildElementType(type, property);
     const definition = createEmptyChildrenDefinition(type, childType);
 
@@ -338,7 +352,7 @@ export function buildChildrenEntry(type: Function, property: string, metadataLis
         });
     }
 
-    populateFromType(definition, childType);
+    populateFromType(definition, childType, 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
@@ -381,9 +395,14 @@ export function buildChildrenEntry(type: Function, property: string, metadataLis
  * 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.
  * @returns The wire-shaped nested definition.
  */
-export function buildNestedEntry(type: Function, property: string): ChildrenDefinitionLike {
+export function buildNestedEntry(
+    type: Function,
+    property: string,
+    collectSharedMapping?: (prototype: object, property: string) => void
+): ChildrenDefinitionLike {
     const nestedType = resolveNestedType(type, property);
     const definition = createEmptyChildrenDefinition(type, nestedType);
     definition.IdentifiedBy = notSetPropertyPath;
@@ -395,6 +414,6 @@ export function buildNestedEntry(type: Function, property: string): ChildrenDefi
         definition.RemovedWith.push({ Key: eventType, Value: { Key: '$eventSourceId', ParentKey: '' } });
     }
 
-    populateFromType(definition, nestedType);
+    populateFromType(definition, nestedType, collectSharedMapping);
     return definition;
 }

package/projections/modelBound/fromAll.ts

@@ -5,6 +5,7 @@ import 'reflect-metadata';
 import { TypeIntrospector } from '../../types/index.js';
 import { decorateModelBoundProperty } from '../../types/modelBoundProperty.js';
 import { ChroniclePropertyDecorator, getPropertyMetadata } from '../../types/propertyDecoratorMetadata.js';
+import { getFromAllEventsMetadata } from './fromAllEvents.js';
 
 /** Metadata stored by the fromAll property decorator. */
 export interface FromAllMetadata {
@@ -21,7 +22,9 @@ const METADATA_KEY = 'chronicle:projection:fromAll';
  * event type the projection is built from - the convention-based counterpart to declaring the same
  * mapping on every individual `fromEvent`. Equivalent to {@link fromEvery} for model-bound
  * projections.
- * @deprecated In the next major, @fromAll subscribes to every event type like fluent fromAll() and .NET [FromAll]; use @fromEvery to keep the current behavior.
+ * @deprecated @fromAll remains a supported, deprecated alias for restricted mappings; prefer @fromEvery.
+ * Contrary to the earlier 'next major' announcement, its behavior will not change;
+ * use @fromAllEvents to opt into all-event subscriptions.
  * @param property - Optional event property name. If not specified, uses the model property name.
  * @param contextProperty - Optional event context property name.
  * @returns A property decorator.
@@ -35,11 +38,13 @@ export function fromAll(property?: string, contextProperty?: string): ChronicleP
 }
 
 /**
- * Retrieves fromAll metadata stored on the given property.
+ * Retrieves fromAll metadata stored on the given property, falling back to fromAllEvents metadata
+ * for compatibility with existing model discovery. This reader does not imply an all-event subscription.
  * @param target - The class prototype.
  * @param propertyKey - The property name.
  * @returns The fromAll metadata, or undefined if not decorated.
  */
 export function getFromAllMetadata(target: object, propertyKey: string): FromAllMetadata | undefined {
-    return getPropertyMetadata<FromAllMetadata>(METADATA_KEY, target, propertyKey);
+    return getPropertyMetadata<FromAllMetadata>(METADATA_KEY, target, propertyKey)
+        ?? getFromAllEventsMetadata(target, propertyKey);
 }

package/projections/modelBound/fromAllEvents.ts

@@ -0,0 +1,48 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { TypeIntrospector } from '../../types/index.js';
+import { decorateModelBoundProperty } from '../../types/modelBoundProperty.js';
+import { ChroniclePropertyDecorator, getPropertyMetadata } from '../../types/propertyDecoratorMetadata.js';
+import type { FromAllEventsMetadata } from './FromAllEventsMetadata.js';
+
+const METADATA_KEY = 'chronicle:projection:fromAllEvents';
+
+/**
+ * On a root property, subscribes the projection to every event type, including events not declared
+ * with `fromEvent`. The model has one shared All block: opting in makes every root
+ * `@fromEvery`/`@fromAll` mapping (including inherited ones) an all-event mapping that also applies
+ * to children. Restricted and all-event shared mappings cannot be mixed in one model.
+ * `@fromEvery`/`@fromAll` mappings on child or nested types are not collected, unlike .NET,
+ * which also collects child [FromEvery] mappings.
+ * On a child or nested member, contributes its bare property name to the root All block and sets
+ * IncludeChildren for the shared block, including the root's restricted shared mappings, without
+ * widening the root subscription. With kernel 19.26.2, when the child's creating event is explicitly
+ * subscribed at the root, it updates the root's shared mappings and creates the child without
+ * populating its shared mapped values. Opt into `@fromAllEvents` at the root to populate child values
+ * in this case. Takes precedence over `fromEvery` and the deprecated `fromAll` alias on the same property.
+ * Opting in changes the definition and may trigger replay; unrelated events can create rows or clear
+ * mapped properties. Use `fromEvery` without `fromAllEvents` on the model or its children to keep
+ * shared mappings restricted to already-subscribed events and the root.
+ * @param property - Optional event property name. If not specified, uses the model property name.
+ * @param contextProperty - Optional event context property name.
+ * @returns A property decorator.
+ */
+export function fromAllEvents(property?: string, contextProperty?: string): ChroniclePropertyDecorator {
+    return decorateModelBoundProperty((target: object, propertyKey: string | symbol) => {
+        TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, propertyKey.toString());
+        const metadata: FromAllEventsMetadata = { property, contextProperty };
+        Reflect.defineMetadata(METADATA_KEY, metadata, target, propertyKey.toString());
+    });
+}
+
+/**
+ * Retrieves the explicit all-event subscription metadata stored on the given property.
+ * @param target - The class prototype.
+ * @param propertyKey - The property name.
+ * @returns The fromAllEvents metadata, or undefined if not decorated.
+ */
+export function getFromAllEventsMetadata(target: object, propertyKey: string): FromAllEventsMetadata | undefined {
+    return getPropertyMetadata<FromAllEventsMetadata>(METADATA_KEY, target, propertyKey);
+}

package/projections/modelBound/index.ts

@@ -37,6 +37,8 @@ export { fromEvery, getFromEveryMetadata } from './fromEvery.js';
 export type { FromEveryMetadata } from './fromEvery.js';
 export { fromAll, getFromAllMetadata } from './fromAll.js';
 export type { FromAllMetadata } from './fromAll.js';
+export { fromAllEvents, getFromAllEventsMetadata } from './fromAllEvents.js';
+export type { FromAllEventsMetadata } from './FromAllEventsMetadata.js';
 export { noAutoMap, isNoAutoMap, isPropertyNoAutoMap } from './noAutoMap.js';
 export { eventSequence, eventLog, getEventSequenceMetadata } from './eventSequence.js';
 export { variantOf, getVariantOfMetadata } from './variantOf.js';

package/types/modelBoundPropertyMetadata.ts

@@ -12,7 +12,7 @@ const finalizedMetadata = new FinalizationRegistry<WeakRef<object>>(reference =>
 
 export const modelBoundPropertyKeys = [
     'setFrom', 'setFromContext', 'setValue', 'addFrom', 'subtractFrom',
-    'increment', 'decrement', 'count', 'childrenFrom', 'join', 'fromEvery', 'fromAll'
+    'increment', 'decrement', 'count', 'childrenFrom', 'join', 'fromEvery', 'fromAll', 'fromAllEvents'
 ].map(name => `chronicle:projection:${name}`);
 
 /** Records a standard-decorated class with an event mapping on one of its fields. */