@cratis/chronicle 6.42.2 → 6.44.0

package/projections/ProjectionDefinitionCompiler.ts

@@ -37,6 +37,7 @@ import { getChildrenFromMetadata } from './modelBound/childrenFrom.js';
 import { getClearWithPropertyMetadata } from './modelBound/clearWith.js';
 import { getEventSequenceMetadata } from './modelBound/eventSequence.js';
 import { getFromAllMetadata } from './modelBound/fromAll.js';
+import { getFromAllEventsMetadata } from './modelBound/fromAllEvents.js';
 import { getFromEveryMetadata } from './modelBound/fromEvery.js';
 import { getFromEventMetadata } from './modelBound/fromEvent.js';
 import { isModelBoundProjection } from './modelBound/isModelBoundProjection.js';
@@ -290,6 +291,27 @@ export class ProjectionDefinitionCompiler {
         const removedWithJoinByEventType = new Map<string, { Key: ContractEventType; Value: { Key: string } }>();
         const childrenByProperty: Record<string, ChildrenDefinitionLike> = {};
         const nestedByProperty: Record<string, ChildrenDefinitionLike> = {};
+        const allProperties: Record<string, string> = {};
+        const subscribesToAllEvents = properties.some(property => getFromAllEventsMetadata(prototype, property) !== undefined);
+        if (subscribesToAllEvents) overrides.set('SubscribesToAllEvents', '@fromAllEvents');
+        let includeChildren = false;
+        const collectSharedMapping = (memberPrototype: object, property: string, isRoot = false) => {
+            const fromAllEvents = getFromAllEventsMetadata(memberPrototype, property);
+            // Preserve legacy child behavior: only the new decorator contributes child mappings.
+            const fromEvery = isRoot ? getFromEveryMetadata(memberPrototype, property) : undefined;
+            const mapping = fromAllEvents ?? fromEvery ?? (isRoot ? getFromAllMetadata(memberPrototype, property) : undefined);
+            if (!mapping) return;
+            if (fromAllEvents) {
+                includeChildren = true;
+                overrides.set('All', '@fromAllEvents');
+            }
+            // .NET collects child and nested members by bare name into the root All block,
+            // not by a path prefixed with the containing collection or nested property.
+            allProperties[property] = mapping.contextProperty
+                ? eventContextPropertyExpression(mapping.contextProperty)
+                : (mapping.property ?? property);
+            overrides.set(`All.Properties.${property}`, fromAllEvents ? '@fromAllEvents' : fromEvery ? '@fromEvery' : '@fromAll');
+        };
 
         const fromEvents = getFromEventMetadata(type);
         for (const fromEvent of fromEvents) {
@@ -363,11 +385,11 @@ export class ProjectionDefinitionCompiler {
             }
             const childrenFromList = getChildrenFromMetadata(prototype, property);
             if (childrenFromList.length > 0) {
-                childrenByProperty[property] = buildChildrenEntry(type, property, childrenFromList);
+                childrenByProperty[property] = buildChildrenEntry(type, property, childrenFromList, collectSharedMapping);
             }
             const propertyIsNested = isNested(prototype, property);
             if (propertyIsNested) {
-                nestedByProperty[property] = buildNestedEntry(type, property);
+                nestedByProperty[property] = buildNestedEntry(type, property, collectSharedMapping);
             }
             // A scalar root property clears back to no value when the given event is observed.
             // Nested single-object clearWith is handled by buildNestedEntry instead.
@@ -378,16 +400,7 @@ export class ProjectionDefinitionCompiler {
                     overrides.set(`${eventContractPath('From', toContractEventType(clearWith.eventType))}.Properties.${property}`, '@clearWith');
                 }
             }
-        }
-
-        const allProperties: Record<string, string> = {};
-        for (const property of properties) {
-            const fromEvery = getFromEveryMetadata(prototype, property) ?? getFromAllMetadata(prototype, property);
-            if (fromEvery) {
-                allProperties[property] = fromEvery.contextProperty
-                    ? eventContextPropertyExpression(fromEvery.contextProperty)
-                    : (fromEvery.property ?? property);
-            }
+            collectSharedMapping(prototype, property, true);
         }
 
         let from = Array.from(fromByEventType.values());
@@ -446,9 +459,10 @@ export class ProjectionDefinitionCompiler {
             FromEvery: [],
             All: {
                 Properties: allProperties,
-                IncludeChildren: false,
+                IncludeChildren: includeChildren,
                 AutoMap: AutoMap.Inherit
             },
+            ...(subscribesToAllEvents ? { SubscribesToAllEvents: true } : {}),
             RemovedWith: Array.from(removedWithByEventType.values()),
             RemovedWithJoin: Array.from(removedWithJoinByEventType.values()),
             LastUpdated: { Value: '' },
@@ -458,18 +472,11 @@ export class ProjectionDefinitionCompiler {
             Nested: nestedByProperty
         };
         const provenance = captureProjectionProvenance({ ...definition, From: preLoweringFrom, Join: preLoweringJoin }, true, overrides);
-        if (Object.keys(allProperties).length && Object.keys(allProperties).every(property =>
+        if (!includeChildren && Object.keys(allProperties).length && Object.keys(allProperties).every(property =>
             getFromAllMetadata(prototype, property) && !getFromEveryMetadata(prototype, property))) {
             const index = provenance.findIndex(entry => entry.contractPath === 'All');
             if (index >= 0) provenance[index] = { contractPath: 'All', declaration: '@fromAll' };
         }
-        for (const property of Object.keys(allProperties)) {
-            if (getFromAllMetadata(prototype, property) && !getFromEveryMetadata(prototype, property)) {
-                const path = `All.Properties.${property}`;
-                const index = provenance.findIndex(entry => entry.contractPath === path);
-                if (index >= 0) provenance[index] = { contractPath: path, declaration: '@fromAll' };
-            }
-        }
         if (variant) {
             provenance.push({ contractPath: 'Variant', declaration: '@variantOf' });
             provenance.push({ contractPath: 'Variant.Key', declaration: '@variantOf' });

package/projections/for_ProjectionDefinitionCompiler/against_a_kernel/when_subscribing_with_from_all_events.integration.spec.ts

@@ -0,0 +1,202 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { randomUUID } from 'node:crypto';
+import { field } from '@cratis/fundamentals';
+import { ObserverRunningState } from '@cratis/chronicle.contracts';
+import { afterAll, beforeAll, chai, describe, it } from 'vitest';
+import { ChronicleClient } from '../../../ChronicleClient.js';
+import { ChronicleOptions } from '../../../ChronicleOptions.js';
+import type { IClientArtifactsProvider } from '../../../artifacts/index.js';
+import type { ChronicleConnection } from '../../../connection/index.js';
+import { eventType } from '../../../events/index.js';
+import type { IEventStore } from '../../../IEventStore.js';
+import { childrenFrom, fromAll, fromAllEvents, fromEvery, fromEvent } from '../../index.js';
+
+chai.should();
+
+const connectionString = process.env.CHRONICLE_INTEGRATION_CONNECTION_STRING;
+
+@eventType()
+class Started {
+    @field(String) value = '';
+}
+
+@eventType()
+class ChildAdded {
+    @field(String) childId = '';
+    @field(String) value = '';
+}
+
+@eventType()
+class Unrelated {
+    @field(String) marker = '';
+}
+
+class Child {
+    @field(String) id = '';
+    @field(String) lastValue = '';
+}
+
+class AllOnly {
+    @field(String) @fromAllEvents(undefined, 'eventSourceId') source = '';
+}
+
+@fromEvent(Started)
+class AllWithChildren {
+    @field(String) @fromEvery('ignored') @fromAllEvents('value') lastValue = '';
+    @field(Array, { genericArguments: [Child] }) @childrenFrom(ChildAdded, 'childId') children: Child[] = [];
+}
+
+@fromEvent(Started)
+class RestrictedWithChildren {
+    @field(String) @fromAll('value') lastValue = '';
+    @field(Array, { genericArguments: [Child] }) @childrenFrom(ChildAdded, 'childId') children: Child[] = [];
+}
+
+class AllMappedChild {
+    @field(String) id = '';
+    @field(String) @fromAllEvents('value') lastValue = '';
+}
+
+class AllWithChildMappings {
+    @field(String) @fromAllEvents(undefined, 'eventSourceId') source = '';
+    @field(String) lastValue = '';
+    @field(Array, { genericArguments: [AllMappedChild] }) @childrenFrom(ChildAdded, 'childId') children: AllMappedChild[] = [];
+}
+
+// Without root all-event subscription, the shared All block needs a root From entry
+// for ChildAdded as well as the child's creating entry.
+@fromEvent(Started)
+@fromEvent(ChildAdded)
+class ChildOnlyMappings {
+    @field(String) @fromEvery('value') rootValue = '';
+    @field(Array, { genericArguments: [AllMappedChild] }) @childrenFrom(ChildAdded, 'childId') children: AllMappedChild[] = [];
+}
+
+const artifacts: IClientArtifactsProvider = {
+    eventTypes: [Started, ChildAdded, Unrelated],
+    readModels: [AllOnly, AllWithChildren, RestrictedWithChildren, AllWithChildMappings, ChildOnlyMappings],
+    projections: [], reactors: [], reducers: [], seeders: [], constraints: [], webhooks: [],
+    eventTypeMigrations: [], globalForHandlers: []
+};
+
+async function eventually<T>(read: () => Promise<T>, accept: (value: T) => boolean): Promise<T> {
+    const deadline = Date.now() + 20_000;
+    let value = await read();
+    while (!accept(value)) {
+        if (Date.now() > deadline) {
+            const state = JSON.stringify(value, (_key, member: unknown) => typeof member === 'bigint' ? member.toString() : member);
+            throw new Error(`Timed out waiting for the projected state: ${state}`);
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+        value = await read();
+    }
+    return value;
+}
+
+describe.skipIf(!connectionString && !process.env.CI)('when opting into fromAllEvents against a kernel', () => {
+    const knownSource = randomUUID();
+    const unrelatedSource = randomUUID();
+    const sentinelSource = randomUUID();
+    const storeName = `AllEvents${randomUUID().replaceAll('-', '').slice(0, 12)}`;
+    let client: ChronicleClient;
+    let store: IEventStore;
+    let allOnly: AllOnly | null;
+    let unrelatedAll: AllWithChildren | null;
+    let unrelatedRestricted: RestrictedWithChildren | null;
+    let allAfterStarted: AllWithChildren | null;
+    let allAfterChild: AllWithChildren | null;
+    let restrictedAfterChild: RestrictedWithChildren | null;
+    let allAfterUnrelated: AllWithChildren | null;
+    let restrictedAfterUnrelated: RestrictedWithChildren | null;
+    let allChildMappingsAfterChild: AllWithChildMappings | null;
+    let childOnlyAfterChild: ChildOnlyMappings | null;
+    let childOnlyAfterUnrelated: ChildOnlyMappings | null;
+    let unrelatedChildOnly: ChildOnlyMappings | null;
+
+    async function append(source: string, event: object): Promise<bigint> {
+        const result = await store.eventLog.append(source, event);
+        result.isSuccess.should.be.true;
+        return result.sequenceNumber.value;
+    }
+
+    async function waitForObserver(observerId: string, sequenceNumber: bigint): Promise<void> {
+        const connection = (store as unknown as { _connection: ChronicleConnection })._connection;
+        await eventually(() => connection.observers.getObserverInformation({
+            EventStore: storeName,
+            Namespace: 'Default',
+            ObserverId: observerId,
+            EventSequenceId: 'event-log'
+        }), observer => observer.IsSubscribed && observer.RunningState === ObserverRunningState.Active &&
+            observer.LastHandledEventSequenceNumber >= sequenceNumber);
+    }
+
+    beforeAll(async () => {
+        client = new ChronicleClient(ChronicleOptions.fromConnectionString(connectionString!, {
+            discoveryPatterns: [], clientArtifactsProvider: artifacts
+        }));
+        store = await client.getEventStore(storeName);
+
+        await append(knownSource, Object.assign(new Started(), { value: 'started' }));
+        allAfterStarted = await eventually(() => store.readModels.findInstanceById(AllWithChildren, knownSource), model => model?.lastValue === 'started');
+        await eventually(() => store.readModels.findInstanceById(RestrictedWithChildren, knownSource), model => model?.lastValue === 'started');
+        await append(knownSource, Object.assign(new ChildAdded(), { childId: 'child-one', value: 'child-value' }));
+        allAfterChild = await eventually(() => store.readModels.findInstanceById(AllWithChildren, knownSource), model => model?.children?.length === 1);
+        restrictedAfterChild = await eventually(() => store.readModels.findInstanceById(RestrictedWithChildren, knownSource), model => model?.children?.length === 1);
+        childOnlyAfterChild = await eventually(() => store.readModels.findInstanceById(ChildOnlyMappings, knownSource), model => model?.children?.length === 1);
+        allChildMappingsAfterChild = await eventually(() => store.readModels.findInstanceById(AllWithChildMappings, knownSource), model => model?.children?.length === 1);
+
+        await append(knownSource, Object.assign(new Unrelated(), { marker: 'no-value' }));
+        allAfterUnrelated = await eventually(() => store.readModels.findInstanceById(AllWithChildren, knownSource),
+            model => model !== null && (model.lastValue === null || model.lastValue === undefined));
+
+        await append(unrelatedSource, Object.assign(new Unrelated(), { marker: 'new-source' }));
+        allOnly = await eventually(() => store.readModels.findInstanceById(AllOnly, unrelatedSource), model => model !== null);
+        unrelatedAll = await eventually(() => store.readModels.findInstanceById(AllWithChildren, unrelatedSource), model => model !== null);
+        // A subscribed sentinel advances each restricted observer past both unrelated events.
+        // Progress on an all-event projection is not a barrier for another observer.
+        const sentinelSequenceNumber = await append(sentinelSource, Object.assign(new Started(), { value: 'sentinel' }));
+        await waitForObserver('RestrictedWithChildren', sentinelSequenceNumber);
+        await waitForObserver('ChildOnlyMappings', sentinelSequenceNumber);
+        restrictedAfterUnrelated = await store.readModels.findInstanceById(RestrictedWithChildren, knownSource);
+        unrelatedRestricted = await store.readModels.findInstanceById(RestrictedWithChildren, unrelatedSource);
+        childOnlyAfterUnrelated = await store.readModels.findInstanceById(ChildOnlyMappings, knownSource);
+        unrelatedChildOnly = await store.readModels.findInstanceById(ChildOnlyMappings, unrelatedSource);
+    });
+
+    afterAll(() => client?.dispose());
+
+    it('should subscribe a model with only fromAllEvents and map event context', () => allOnly!.source.should.equal(unrelatedSource));
+    it('should create a row for an unrelated event source only after opting in', () => {
+        (unrelatedAll !== null).should.be.true;
+        (unrelatedRestricted === null).should.be.true;
+    });
+    it('should give the explicit all-event mapping precedence over fromEvery', () => allAfterStarted!.lastValue.should.equal('started'));
+    it('should apply the root all-event mapping to a child', () => {
+        allAfterChild!.children.should.have.lengthOf(1);
+        allAfterChild!.children[0].id.should.equal('child-one');
+        allAfterChild!.children[0].lastValue.should.equal('child-value');
+    });
+    it('should not propagate the deprecated restricted alias mapping to children', () => {
+        restrictedAfterChild!.children.should.have.lengthOf(1);
+        (restrictedAfterChild!.children[0].lastValue !== 'child-value').should.be.true;
+    });
+    it('should clear the mapped root property on an unrelated event without that value', () => {
+        (allAfterUnrelated!.lastValue === null || allAfterUnrelated!.lastValue === undefined).should.be.true;
+    });
+    it('should leave the restricted alias unchanged on an unrelated event', () => restrictedAfterUnrelated!.lastValue.should.equal(restrictedAfterChild!.lastValue));
+    it('should apply a child-declared all-event mapping through the shared root All block', () => {
+        allChildMappingsAfterChild!.children[0].lastValue.should.equal('child-value');
+        // The child event's key routes the all-event fallback to the child, not the root.
+        allChildMappingsAfterChild!.lastValue.should.equal('started');
+    });
+    it('should keep the root subscription restricted when only the child declares fromAllEvents', () => {
+        childOnlyAfterChild!.rootValue.should.equal('child-value');
+        childOnlyAfterChild!.children[0].id.should.equal('child-one');
+        // The explicitly subscribed root From entry maps the root, not the child's shared values.
+        (childOnlyAfterChild!.children[0].lastValue === undefined).should.be.true;
+        childOnlyAfterUnrelated!.rootValue.should.equal('child-value');
+        (unrelatedChildOnly === null).should.be.true;
+    });
+});

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;
+}