@cratis/chronicle 6.41.0 → 6.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/chronicle",
-    "version": "6.41.0",
+    "version": "6.42.0",
     "description": "Event sourcing for TypeScript and Node.js — the idiomatic client for Cratis Chronicle, the open-source event-sourcing database",
     "author": "Cratis",
     "license": "MIT",
@@ -173,7 +173,7 @@
         "clean": "rm -rf dist",
         "test": "vitest run",
         "test:integration": "vitest run --config vitest.integration.config.ts",
-        "test:standard-types": "tsc --ignoreConfig --noEmit --target es2022 --module es2022 --moduleResolution bundler --lib es2022,esnext.decorators --types node --skipLibCheck --strict schemas/decorators.standard.spec.ts projections/declarative/addChildCompatibility.standard.spec.ts projections/modelBound/decorators.standard.spec.ts events/classDecorators.standard.spec.ts reactors/decorators.standard.spec.ts readModels/standardFallbacks.standard.spec.ts readModels/registration.standard.spec.ts for_ChronicleClient/when_registering_artifacts/with_standard_property_mappings.standard.spec.ts artifacts/validateArtifactSchemas.spec.ts testing/for_EventScenario/when_appending_concept_fields/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_scoped_constraints/with_standard_decorators.standard.spec.ts schemas/for_JsonSchemaGenerator/when_generating_children/with_standard_decorators.standard.spec.ts events/for_handles/when_decorating_a_method.standard.spec.ts testing/for_ReadModelScenario/when_evaluating_arithmetic/with_standard_decorators.standard.spec.ts testing/for_ReadModelScenario/when_evaluating_joins/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_field_types/with_standard_decorators.standard.spec.ts",
+        "test:standard-types": "tsc --ignoreConfig --noEmit --target es2022 --module es2022 --moduleResolution bundler --lib es2022,esnext.decorators --types node --skipLibCheck --strict schemas/decorators.standard.spec.ts projections/declarative/addChildCompatibility.standard.spec.ts projections/modelBound/decorators.standard.spec.ts events/classDecorators.standard.spec.ts reactors/decorators.standard.spec.ts readModels/standardFallbacks.standard.spec.ts readModels/registration.standard.spec.ts for_ChronicleClient/when_registering_artifacts/with_standard_property_mappings.standard.spec.ts artifacts/validateArtifactSchemas.spec.ts testing/for_EventScenario/when_appending_concept_fields/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_scoped_constraints/with_standard_decorators.standard.spec.ts schemas/for_JsonSchemaGenerator/when_generating_children/with_standard_decorators.standard.spec.ts events/for_handles/when_decorating_a_method.standard.spec.ts testing/for_ReadModelScenario/when_evaluating_arithmetic/with_standard_decorators.standard.spec.ts testing/for_ReadModelScenario/when_evaluating_joins/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_field_types/with_standard_decorators.standard.spec.ts eventSequences/for_EventSequence/when_appending/with_subject_annotations.standard.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_from_all.standard.spec.ts",
         "test:native": "node ./scripts/check-native-esm.mjs"
     },
     "dependencies": {

package/projections/captureProjectionProvenance.ts

@@ -39,6 +39,7 @@ export function captureProjectionProvenance(definition: Record<string, unknown>,
             add(`${section}.${property}`, modelBound ? (section === 'Children' ? '@childrenFrom' : '@nested') : `.${section.toLowerCase()}`);
         }
     }
+    if (definition.SubscribesToAllEvents === true) add('SubscribesToAllEvents', `${prefix}fromAll`);
     const all = definition.All as { Properties?: Record<string, string>; IncludeChildren?: boolean } | undefined;
     if (all?.IncludeChildren || Object.keys(all?.Properties ?? {}).length) add('All', modelBound ? '@fromEvery' : '.fromEvery');
     for (const property of Object.keys(all?.Properties ?? {})) add(`All.Properties.${property}`, modelBound ? '@fromEvery' : '.fromEvery');

package/projections/declarative/FromAllBuilder.ts

@@ -0,0 +1,49 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { PropertyAccessor, PropertyPathResolverProxyHandler } from '@cratis/fundamentals';
+import { AllSetBuilder } from './AllSetBuilder.js';
+import type { IAllSetBuilder } from './IAllSetBuilder.js';
+import type { IFromAllBuilder } from './IFromAllBuilder.js';
+
+/** Accumulates all-event mappings without restricting the event subscription to known types. */
+export class FromAllBuilder<TReadModel> implements IFromAllBuilder<TReadModel> {
+    readonly properties: Record<string, string> = {};
+
+    /** @inheritdoc */
+    set(readModelPropertyAccessor: PropertyAccessor<TReadModel>): IAllSetBuilder<TReadModel, IFromAllBuilder<TReadModel>> {
+        return new AllSetBuilder<TReadModel, IFromAllBuilder<TReadModel>>(
+            this.targetProperty(readModelPropertyAccessor),
+            (property, expression) => { this.properties[property] = expression; },
+            this
+        );
+    }
+
+    /** @inheritdoc */
+    count(readModelPropertyAccessor: PropertyAccessor<TReadModel>, contextPropertyName?: string): IFromAllBuilder<TReadModel> {
+        return this.operation(readModelPropertyAccessor, '$count', contextPropertyName);
+    }
+
+    /** @inheritdoc */
+    increment(readModelPropertyAccessor: PropertyAccessor<TReadModel>, contextPropertyName?: string): IFromAllBuilder<TReadModel> {
+        return this.operation(readModelPropertyAccessor, '$increment', contextPropertyName);
+    }
+
+    /** @inheritdoc */
+    decrement(readModelPropertyAccessor: PropertyAccessor<TReadModel>, contextPropertyName?: string): IFromAllBuilder<TReadModel> {
+        return this.operation(readModelPropertyAccessor, '$decrement', contextPropertyName);
+    }
+
+    private operation(accessor: PropertyAccessor<TReadModel>, expression: string, contextPropertyName?: string): this {
+        const property = this.targetProperty(accessor);
+        const target = contextPropertyName === undefined ? property : `${property}.$eventContext.${contextPropertyName}`;
+        this.properties[target] = expression;
+        return this;
+    }
+
+    private targetProperty(accessor: PropertyAccessor<TReadModel>): string {
+        const handler = new PropertyPathResolverProxyHandler();
+        accessor(new Proxy({}, handler) as TReadModel);
+        return handler.property;
+    }
+}

package/projections/declarative/IFromAllBuilder.ts

@@ -0,0 +1,39 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { PropertyAccessor } from '@cratis/fundamentals';
+import type { IAllSetBuilder } from './IAllSetBuilder.js';
+
+/** Configures mappings for every event, including types not otherwise declared by the projection. */
+export interface IFromAllBuilder<TReadModel> {
+    /**
+     * Starts an assignment to a read-model property.
+     * @param readModelPropertyAccessor - Target property accessor.
+     * @returns The assignment builder, continuing with this all-events builder.
+     */
+    set(readModelPropertyAccessor: PropertyAccessor<TReadModel>): IAllSetBuilder<TReadModel, IFromAllBuilder<TReadModel>>;
+
+    /**
+     * Counts every event, optionally under a dynamic dictionary key.
+     * @param readModelPropertyAccessor - Scalar or dictionary target accessor.
+     * @param contextPropertyName - Optional event-context path for the dictionary key, such as `eventType.id`.
+     * @returns This builder for chaining.
+     */
+    count(readModelPropertyAccessor: PropertyAccessor<TReadModel>, contextPropertyName?: string): IFromAllBuilder<TReadModel>;
+
+    /**
+     * Increments a property for every event, optionally under a dynamic dictionary key.
+     * @param readModelPropertyAccessor - Scalar or dictionary target accessor.
+     * @param contextPropertyName - Optional event-context path for the dictionary key.
+     * @returns This builder for chaining.
+     */
+    increment(readModelPropertyAccessor: PropertyAccessor<TReadModel>, contextPropertyName?: string): IFromAllBuilder<TReadModel>;
+
+    /**
+     * Decrements a property for every event, optionally under a dynamic dictionary key.
+     * @param readModelPropertyAccessor - Scalar or dictionary target accessor.
+     * @param contextPropertyName - Optional event-context path for the dictionary key.
+     * @returns This builder for chaining.
+     */
+    decrement(readModelPropertyAccessor: PropertyAccessor<TReadModel>, contextPropertyName?: string): IFromAllBuilder<TReadModel>;
+}

package/projections/declarative/IProjectionBuilderFor.ts

@@ -3,6 +3,7 @@
 
 import { PropertyAccessor } from '@cratis/fundamentals';
 import { IProjectionBuilder } from './IProjectionBuilder.js';
+import type { IFromAllBuilder } from './IFromAllBuilder.js';
 
 /**
  * Defines the top-level projection builder for a specific read model type.
@@ -11,6 +12,14 @@ import { IProjectionBuilder } from './IProjectionBuilder.js';
  */
 export interface IProjectionBuilderFor<TReadModel>
     extends IProjectionBuilder<TReadModel, IProjectionBuilderFor<TReadModel>> {
+    /**
+     * Subscribes to every event type, including types not explicitly declared.
+     * Mappings share the All block with fromEvery. Unlike fromEvery, this expands the subscription.
+     * @param builderCallback - Callback for configuring all-event assignments and counters.
+     * @returns This builder for fluent chaining.
+     */
+    fromAll(builderCallback: (builder: IFromAllBuilder<TReadModel>) => void): IProjectionBuilderFor<TReadModel>;
+
     /**
      * Specifies the event sequence this projection should read from.
      * @param eventSequenceId - The identifier of the event sequence.

package/projections/declarative/ProjectionBuilderFor.ts

@@ -9,6 +9,8 @@ import { ChildrenBuilder } from './ChildrenBuilder.js';
 import { IChildrenBuilder } from './IChildrenBuilder.js';
 import { INestedBuilder } from './INestedBuilder.js';
 import { IProjectionBuilderFor } from './IProjectionBuilderFor.js';
+import type { IFromAllBuilder } from './IFromAllBuilder.js';
+import { FromAllBuilder } from './FromAllBuilder.js';
 import { NestedBuilder } from './NestedBuilder.js';
 import { ChildrenDefinitionLike, ContractEventType, ProjectionBuilderCore } from './ProjectionBuilderCore.js';
 
@@ -22,6 +24,7 @@ export class ProjectionBuilderFor<TReadModel> extends ProjectionBuilderCore<TRea
     private _containerName: string | undefined;
     private _rewindable: boolean = true;
     private _active: boolean = true;
+    private _subscribesToAllEvents = false;
     private _variantIdentity: Function | undefined;
     private _variantKey: string | undefined;
     private readonly _enteringEventTypes: ContractEventType[] = [];
@@ -31,6 +34,19 @@ export class ProjectionBuilderFor<TReadModel> extends ProjectionBuilderCore<TRea
         this._autoMap = AutoMap.Enabled;
     }
 
+    /** @inheritdoc */
+    fromAll(builderCallback: (builder: IFromAllBuilder<TReadModel>) => void): this {
+        const builder = new FromAllBuilder<TReadModel>();
+        builderCallback(builder);
+        this._subscribesToAllEvents = true;
+        this._all = {
+            Properties: { ...this._all.Properties, ...builder.properties },
+            IncludeChildren: true,
+            AutoMap: AutoMap.Inherit
+        };
+        return this;
+    }
+
     /** @inheritdoc */
     fromEventSequence(eventSequenceId: string): this {
         this._eventSequenceId = eventSequenceId;
@@ -146,6 +162,7 @@ export class ProjectionBuilderFor<TReadModel> extends ProjectionBuilderCore<TRea
             Children: this._children,
             FromEvery: [],
             All: this._all,
+            ...(this._subscribesToAllEvents ? { SubscribesToAllEvents: true } : {}),
             FromEventProperty: undefined,
             RemovedWith: this._removedWith,
             RemovedWithJoin: this._removedWithJoin,

package/projections/declarative/for_ProjectionBuilderFor/when_subscribing_to_all_events.spec.ts

@@ -0,0 +1,111 @@
+// 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 { beforeEach, chai, describe, it } from 'vitest';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import { ProjectionBuilderFor, projection, type IFromAllBuilder, type IProjectionBuilderFor } from '../index.js';
+import { ReadModelScenario } from '../../../testing/ReadModelScenario.js';
+import { UnsupportedProjectionOperation } from '../../../testing/projections/UnsupportedProjectionOperation.js';
+
+chai.should();
+
+class Model {
+    title = '';
+    source = '';
+    lastSequence = '';
+    counted = 0;
+    incremented = 0;
+    decremented = 0;
+    countsByType: Record<string, number> = {};
+}
+class Declared { title = ''; }
+class Removed {}
+eventType('Declared')(Declared);
+eventType('Removed')(Removed);
+
+function mappings(all: IFromAllBuilder<Model>): void {
+    all.set(model => model.title).to(model => model.title)
+        .set(model => model.source).toEventSourceId()
+        .set(model => model.lastSequence).toEventContextProperty('sequenceNumber')
+        .count(model => model.counted)
+        .increment(model => model.incremented)
+        .decrement(model => model.decremented)
+        .count(model => model.countsByType, 'eventType.id');
+}
+
+function fixture(name: string) {
+    return JSON.parse(readFileSync(new URL(`../../../testing/projections/fixtures/${name}.json`, import.meta.url), 'utf8')) as {
+        wireDefinition: { All: object; SubscribesToAllEvents: boolean };
+        expected: Array<{ publicRead: Record<string, Record<string, unknown>> }>;
+    };
+}
+
+for (const name of ['from-all-only', 'from-all-mixed', 'from-all-exclude-children', 'from-all-empty']) {
+    describe(`when subscribing to all events using ${name}`, () => {
+        let definition: Record<string, unknown>;
+        const captured = fixture(name);
+        beforeEach(() => {
+            const builder = new ProjectionBuilderFor<Model>().noAutoMap();
+            if (name === 'from-all-mixed' || name === 'from-all-exclude-children') {
+                builder.from(Declared, from => from.set(model => model.title).toValue('explicit')).removedWith(Removed);
+            }
+            builder.fromAll(name === 'from-all-empty' ? () => {} : mappings);
+            if (name === 'from-all-exclude-children') builder.fromEvery(every => every.excludeChildProjections());
+            definition = builder.build(name, 'OracleReadModel');
+        });
+        it('should emit the all-events subscription captured by the packaged kernel', () => {
+            definition.SubscribesToAllEvents!.should.equal(captured.wireDefinition.SubscribesToAllEvents);
+        });
+        it('should emit the mappings and child flag captured by the packaged kernel', () => {
+            definition.All!.should.deep.equal(captured.wireDefinition.All);
+        });
+        it('should have kernel evidence that an undeclared event creates a read model', () => {
+            captured.expected[0].publicRead['record-a'].id!.should.equal('record-a');
+        });
+    });
+}
+
+describe('when creating a declarative all-event scenario', () => {
+    it('should reject an empty all-event subscription before any events can be seeded', () => {
+        class AllProjection {
+            define(builder: IProjectionBuilderFor<Model>): void { builder.fromAll(() => {}); }
+        }
+        projection('all-scenario', Model)(AllProjection);
+        (() => new ReadModelScenario(Model, { readModels: [Model], eventTypes: [], projections: [AllProjection], reducers: [] }))
+            .should.throw(UnsupportedProjectionOperation, 'SubscribesToAllEvents (.fromAll)');
+    });
+});
+
+describe('when combining fromAll and fromEvery mappings', () => {
+    it('should retain every mapping and never narrow the subscription', () => {
+        const builder = new ProjectionBuilderFor<Model>();
+        builder.fromEvery(every => every.set(model => model.title).to(model => model.title));
+        builder.fromAll(all => all.count(model => model.counted));
+        builder.fromAll(all => all.increment(model => model.incremented, 'eventType.id').decrement(model => model.decremented, 'eventType.id'));
+        builder.fromEvery(every => every.set(model => model.source).toEventSourceId().excludeChildProjections());
+        const definition = builder.build('mixed', 'Model');
+        definition.SubscribesToAllEvents!.should.equal(true);
+        definition.All!.should.deep.equal({ Properties: {
+            title: 'title', counted: '$count', 'incremented.$eventContext.eventType.id': '$increment',
+            'decremented.$eventContext.eventType.id': '$decrement', source: '$eventSourceId'
+        }, IncludeChildren: false, AutoMap: 0 });
+    });
+
+    it('should leave fromEvery subscription behavior unchanged', () => {
+        const builder = new ProjectionBuilderFor<Model>();
+        builder.from(Declared).fromEvery(every => every.set(model => model.title).to(model => model.title));
+        (builder.build('every', 'Model').SubscribesToAllEvents === undefined).should.be.true;
+        const captured = fixture('from-every-restricted');
+        captured.expected[0].publicRead.should.deep.equal({});
+        captured.expected[3].publicRead['record-a'].counted!.should.equal(1);
+        captured.expected[5].publicRead.should.deep.equal({});
+    });
+
+    it('should hash the subscription flag independently of identical mappings', () => {
+        const all = new ProjectionBuilderFor<Model>().fromAll(builder => builder.set(model => model.title).to(model => model.title));
+        const every = new ProjectionBuilderFor<Model>().fromEvery(builder => builder.set(model => model.title).to(model => model.title));
+        all.build('same', 'Model').LastUpdated!.should.not.deep.equal(every.build('same', 'Model').LastUpdated);
+        all.build('same', 'Model').LastUpdated!.should.deep.equal(all.build('same', 'Model').LastUpdated);
+    });
+});

package/projections/declarative/index.ts

@@ -11,6 +11,8 @@ export { AddChildBuilder } from './AddChildBuilder.js';
 export type { ChildAdditionEntry } from './AddChildBuilder.js';
 export { CompositeKeyBuilder } from './CompositeKeyBuilder.js';
 export { FromBuilder } from './FromBuilder.js';
+export { FromAllBuilder } from './FromAllBuilder.js';
+export type { IFromAllBuilder } from './IFromAllBuilder.js';
 export { JoinBuilder } from './JoinBuilder.js';
 export { SetBuilder } from './SetBuilder.js';
 export { AddBuilder } from './AddBuilder.js';

package/projections/for_ProjectionDefinitionCompiler/given/compile_model_bound.ts

@@ -0,0 +1,15 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { Constructor } from '@cratis/fundamentals';
+import type { IClientArtifactsProvider } from '../../../artifacts/IClientArtifactsProvider.js';
+import { ProjectionDefinitionCompiler } from '../../ProjectionDefinitionCompiler.js';
+
+export function compileModelBound(model: Constructor) {
+    const artifacts: IClientArtifactsProvider = {
+        readModels: [model], projections: [], eventTypes: [], globalForHandlers: [], reducers: [],
+        reactors: [], seeders: [], constraints: [], webhooks: [], eventTypeMigrations: []
+    };
+    const compiled = new ProjectionDefinitionCompiler(artifacts, 'test-sink').compile([], [model]);
+    return { compiled, definition: compiled.definitions[0] };
+}

package/projections/for_ProjectionDefinitionCompiler/when_compiling_from_all.spec.ts

@@ -0,0 +1,90 @@
+// 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 { fromAll } from '../modelBound/fromAll.js';
+import { fromEvery } from '../modelBound/fromEvery.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 = '';
+    lastType = '';
+}
+for (const property of ['id', 'title', 'source', 'lastType']) field(String)(Model.prototype, property);
+
+describe('when compiling legacy fromAll without explicit event subscriptions', () => {
+    let result: ReturnType<typeof compileModelBound>;
+    beforeEach(() => {
+        class Candidate extends Model {}
+        fromAll()(Candidate.prototype, 'title');
+        fromAll(undefined, 'sequenceNumber')(Candidate.prototype, 'lastType');
+        fromEvery(undefined, 'eventSourceId')(Candidate.prototype, 'source');
+        result = compileModelBound(Candidate);
+    });
+    it('should keep the alias from expanding the event subscription', () => {
+        (result.definition.SubscribesToAllEvents === undefined).should.be.true;
+        result.definition.From.should.deep.equal([]);
+        result.definition.FromEvery.should.deep.equal([]);
+    });
+    it('should merge content and context mappings with fromEvery into All', () => {
+        result.definition.All!.Properties.should.deep.equal({ title: 'title', lastType: '$eventContext(SequenceNumber)', source: '$eventContext(EventSourceId)' });
+        result.definition.All!.IncludeChildren.should.be.false;
+    });
+    it('should preserve the decorator in the mapping diagnostic', () => {
+        result.compiled.provenance.get(result.definition)!.should.include.deep.members([
+            { contractPath: 'All.Properties.title', declaration: '@fromAll' }
+        ]);
+    });
+});
+
+describe('when using legacy fromAll in a read-model scenario', () => {
+    it('should reject the all-event mapping before events can be seeded', () => {
+        class Candidate extends Model {}
+        fromAll('title')(Candidate.prototype, 'title');
+        (() => new ReadModelScenario(Candidate, { readModels: [Candidate], eventTypes: [], projections: [], reducers: [] }))
+            .should.throw(UnsupportedProjectionOperation, 'All (@fromAll)');
+    });
+});
+
+describe('when compiling legacy fromEvery without fromAll', () => {
+    it('should preserve the existing sparse definition and child flag', () => {
+        class Candidate extends Model {}
+        fromEvery('name')(Candidate.prototype, 'title');
+        const { definition } = compileModelBound(Candidate);
+        (definition.SubscribesToAllEvents === undefined).should.be.true;
+        definition.All!.should.deep.equal({ Properties: { title: 'name' }, IncludeChildren: false, AutoMap: 0 });
+    });
+});
+
+describe('when inheriting legacy fromAll metadata', () => {
+    it('should inherit the restricted mapping without changing a sibling', () => {
+        class AllModel extends Model {}
+        fromAll('name')(AllModel.prototype, 'title');
+        class Derived extends AllModel {}
+        const { definition } = compileModelBound(Derived);
+        (definition.SubscribesToAllEvents === undefined).should.be.true;
+        definition.All!.should.deep.equal({ Properties: { title: 'name' }, IncludeChildren: false, AutoMap: 0 });
+        class EveryModel extends Model {}
+        fromEvery('name')(EveryModel.prototype, 'title');
+        (compileModelBound(EveryModel).definition.SubscribesToAllEvents === undefined).should.be.true;
+    });
+});
+
+describe('when both all-event decorators target the same legacy property', () => {
+    it('should preserve fromEvery mapping precedence', () => {
+        class Candidate extends Model {}
+        fromEvery('oldName')(Candidate.prototype, 'title');
+        fromAll('newName')(Candidate.prototype, 'title');
+        const { definition } = compileModelBound(Candidate);
+        (definition.SubscribesToAllEvents === undefined).should.be.true;
+        definition.All!.Properties.title.should.equal('oldName');
+    });
+});

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

@@ -0,0 +1,69 @@
+// 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 { fromAll } from '../modelBound/fromAll.js';
+import { fromEvery } from '../modelBound/fromEvery.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) @fromAll('name') title = '';
+    @field(String) @fromAll(undefined, 'sequenceNumber') lastType = '';
+    @field(String) @fromEvery(undefined, 'eventSourceId') source = '';
+}
+class EveryModel {
+    @field(String) id = '';
+    @field(String) @fromEvery('name') title = '';
+}
+
+describe('when compiling standard fromAll without explicit event subscriptions', () => {
+    it('should emit restricted shared mappings without constructing the model', () => {
+        const { definition } = compileModelBound(AllModel);
+        should(definition.SubscribesToAllEvents === undefined).be.true;
+        should(definition.From).deep.equal([]);
+        should(definition.FromEvery).deep.equal([]);
+        should(definition.All).deep.equal({ Properties: {
+            title: 'name', lastType: '$eventContext(SequenceNumber)', source: '$eventContext(EventSourceId)'
+        }, IncludeChildren: false, AutoMap: 0 });
+    });
+
+    it('should leave fromEvery subscriptions and child behavior unchanged', () => {
+        const { definition } = compileModelBound(EveryModel);
+        should(definition.SubscribesToAllEvents === undefined).be.true;
+        should(definition.All).deep.equal({ Properties: { title: 'name' }, IncludeChildren: false, AutoMap: 0 });
+    });
+
+    it('should inherit the restricted mappings without expanding subscriptions', () => {
+        class Derived extends AllModel {}
+        const { definition } = compileModelBound(Derived);
+        should(definition.SubscribesToAllEvents === undefined).be.true;
+        should(definition.All).deep.equal(compileModelBound(AllModel).definition.All);
+        should(compileModelBound(EveryModel).definition.SubscribesToAllEvents === undefined).be.true;
+    });
+
+    it('should reject the shared mappings before replay with the standard decorator declaration', () => {
+        class Candidate {
+            @field(String) id = '';
+            @field(String) @fromAll('name') title = '';
+        }
+        should(() => new ReadModelScenario(Candidate, { readModels: [Candidate], eventTypes: [], projections: [], reducers: [] }))
+            .throw(UnsupportedProjectionOperation, 'All (@fromAll)');
+    });
+
+    it('should preserve fromEvery precedence when both decorators target one property', () => {
+        class Both {
+            @field(String) id = '';
+            @field(String) @fromEvery('oldName') @fromAll('newName') title = '';
+        }
+        const { definition } = compileModelBound(Both);
+        should(definition.SubscribesToAllEvents === undefined).be.true;
+        should(definition.All!.Properties.title).equal('oldName');
+    });
+});

package/projections/modelBound/fromAll.ts

@@ -20,7 +20,8 @@ const METADATA_KEY = 'chronicle:projection:fromAll';
  * Property decorator that sets the decorated read model property from a property present on every
  * 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; use whichever name reads better for the property being mapped.
+ * 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.
  * @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.

package/testing/EventScenario.batches.spec.ts

@@ -265,7 +265,7 @@ describe('when appending batches against committed kernel fixtures', () => {
             error => { (error instanceof UnsupportedEventSequenceOperation).should.be.true; }
         );
         await first;
-        for (const options of [{ subject: 'bad subject' }, { tags: ['invalid|tag'] },
+        for (const options of [{ subject: 42 as unknown as string }, { tags: ['invalid|tag'] },
             { concurrencyScope: {} as never }]) {
             await scenario.appendMany('B', [new OracleEventRecorded('second', false)], options).then(
                 () => { throw new Error('Unproven metadata accepted'); },
@@ -450,7 +450,7 @@ describe('when appending batches against committed kernel fixtures', () => {
             ['appendMany.correlationId', () => scenario.appendMany('B', [event()], { correlationId: 'bad-guid' })],
             ['appendMany.entry', () => scenario.appendMany([entry({ unknown: 'value' })])],
             ['appendMany.sourceType', () => scenario.appendMany([entry({ eventSourceType: 'bad source' })])],
-            ['appendMany.subject', () => scenario.appendMany([entry({ subject: '' })], { subject: 'shared' })],
+            ['appendMany.subject', () => scenario.appendMany([entry({ subject: 42 })], { subject: 'shared' })],
             ['appendMany.streamType', () => scenario.appendMany([entry({ eventStreamType: 'bad stream' })])],
             ['appendMany.streamId', () => scenario.appendMany([entry({ eventStreamId: 'bad stream' })])],
             ['appendMany.event', () => scenario.appendMany('B', [new UnregisteredRecorded()])],

package/testing/EventScenario.fixtures.spec.ts

@@ -219,11 +219,11 @@ describe('when appending against committed kernel event fixtures', () => {
     it('should reject prototype getters and non-enumerable append metadata without mutation', async () => {
         const scenario = makeScenario();
         class OptionsWithGetters {
-            get subject() { return 'different-subject'; }
+            get occurred() { return new Date(); }
             get streamId() { return 'different-stream'; }
         }
         await unsupportedAsync(() => scenario.append('A', new OracleEventRecorded('one', true), new OptionsWithGetters()), 'append.options');
-        const hidden = Object.defineProperty({}, 'subject', { value: 'different-subject', enumerable: false });
+        const hidden = Object.defineProperty({}, 'occurred', { value: new Date(), enumerable: false });
         await unsupportedAsync(() => scenario.append('A', new OracleEventRecorded('one', true), hidden), 'append.options');
         scenario.appendedEvents.length.should.equal(0);
         scenario.results.length.should.equal(0);

package/testing/EventScenario.rejections.spec.ts

@@ -233,9 +233,9 @@ describe('when the fixture-bounded event sequence encounters unproven operations
         await rejects(() => subject.append('A', new Recorded(), { correlationId: '00000000-0000-0000-0000-000000000001' }), 'append.options');
         clean(subject);
     });
-    it('should reject plain subject options', async () => {
+    it('should reject non-string subject options', async () => {
         const subject = scenario();
-        await rejects(() => subject.append('A', new Recorded(), { subject: 'other' }), 'append.options');
+        await rejects(() => subject.append('A', new Recorded(), { subject: 42 as unknown as string }), 'append.subject');
         clean(subject);
     });
     it('should reject empty source/type-read event types', async () => {

package/testing/InProcessEventSequence.ts

@@ -37,6 +37,11 @@ import { UnsupportedEventSequenceOperation } from './UnsupportedEventSequenceOpe
 // JS trim() omits U+0085, which the kernel trims. Reject unproven non-ASCII whitespace and controls.
 const unprovenFilterCharacters = /[\u007f-\u009f]|(?=[^\x00-\x7f])\p{White_Space}/u;
 
+function resolveStoredSubject(subject: string | undefined, eventSourceId: string): string {
+    // Match the kernel's string.IsNullOrWhiteSpace, including U+0085 but not U+FEFF.
+    return subject && !/^\p{White_Space}*$/u.test(subject) ? subject : eventSourceId;
+}
+
 function matchesConstrainedValue(value: unknown, content: unknown): boolean {
     // Use production serialization for concepts, not their wrapper object's runtime type.
     // Keep rejecting other unproven conversions, such as a Date assigned to a string field.
@@ -168,13 +173,13 @@ export class InProcessEventSequence implements IEventSequence {
         try {
             if (!event || typeof event !== 'object') throw this.unsupported('append.event', this.id.value, 'Only registered event instances are supported.');
             if (!/^[A-Za-z0-9_-]+$/.test(eventSourceId)) throw this.unsupported('append.source', eventSourceId, 'Only simple source identifiers are fixture-backed.');
-            const route = singleAppendRoute(options, event.constructor.name, (operation, artifact, reason) => this.unsupported(operation, artifact, reason));
+            const route = singleAppendRoute(options, event.constructor.name, (operation, artifact, reason) => this.unsupported(operation, artifact, reason), true);
             const metadata = this._catalog.get(event.constructor);
             if (!metadata) throw this.unsupported('append.event', event.constructor.name, 'Event is not in the selected, validated catalog.');
             let prepared: ReturnType<typeof prepareSingleAppend>;
             let content: Record<string, unknown>;
             try {
-                prepared = prepareSingleAppend(event, this._correlationId ? { correlationId: this._correlationId() } : undefined);
+                prepared = prepareSingleAppend(event, { subject: options?.subject, correlationId: this._correlationId?.() });
                 content = this.checkedContent(event, prepared.content, 'append.content',
                     'Content differs from the event schema; null, missing and extra values are not proven.');
             } catch (error) {
@@ -207,7 +212,7 @@ export class InProcessEventSequence implements IEventSequence {
                     eventStore: this._store, namespace: this._namespace,
                     sequenceNumber: sequenceNumber.value, eventSourceId,
                     eventSourceType: route.sourceType, eventStreamType: route.streamType, eventStreamId: route.streamId,
-                    subject: eventSourceId, hash, causedBy: prepared.identity, observationState: EventObservationState.Initial,
+                    subject: resolveStoredSubject(prepared.subject, eventSourceId), hash, causedBy: prepared.identity, observationState: EventObservationState.Initial,
                     eventType: prepared.eventType, occurred, correlationId: prepared.correlationId.toString(),
                     causation: prepared.causationChain.map(item => ({ type: item.type.name, occurred: item.occurred, properties: { ...item.properties } })),
                     tags: prepared.tags.map(tag => new Tag(tag))
@@ -254,6 +259,9 @@ export class InProcessEventSequence implements IEventSequence {
                 }
                 const individual = entry as EventForEventSourceId;
                 if (individual.occurred !== undefined) this.checkedDate(individual.occurred, 'appendMany.occurred');
+                if (individual.subject !== undefined && individual.subject !== null && typeof individual.subject !== 'string') {
+                    throw this.unsupported('appendMany.subject', this.id.value, 'Subject must be a string.');
+                }
                 const tags = individual.tags;
                 if (tags && (!Array.isArray(tags) || tags.some(tag => typeof tag !== 'string'))) {
                     throw this.unsupported('appendMany.tags', this.id.value, 'Only plain string tags are fixture-backed.');
@@ -288,8 +296,8 @@ export class InProcessEventSequence implements IEventSequence {
                 this.validateSource(eventSourceId, 'appendMany.source');
                 const wire = eventsToAppend[index];
                 for (const [name, value] of Object.entries({ sourceType: wire.EventSourceType, streamType: wire.EventStreamType,
-                    streamId: wire.EventStreamId, subject: wire.Subject })) {
-                    const identifiers = name === 'subject' ? /^[A-Za-z0-9_-]+$/ : /^[A-Za-z0-9_-]*$/;
+                    streamId: wire.EventStreamId })) {
+                    const identifiers = /^[A-Za-z0-9_-]*$/;
                     if (value !== undefined && (typeof value !== 'string' || !identifiers.test(value))) {
                         throw this.unsupported(`appendMany.${name}`, String(value), 'Only simple metadata identifiers are fixture-backed.');
                     }
@@ -307,7 +315,7 @@ export class InProcessEventSequence implements IEventSequence {
                 const stored: AppendedEvent = { eventType, content, context: {
                     eventStore: this._store, namespace: this._namespace, sequenceNumber: sequenceNumber.value, eventSourceId,
                     eventSourceType: wire.EventSourceType || 'Default', eventStreamType: wire.EventStreamType || 'All',
-                    eventStreamId: wire.EventStreamId || 'Default', subject: wire.Subject, hash, causedBy: identity,
+                    eventStreamId: wire.EventStreamId || 'Default', subject: resolveStoredSubject(wire.Subject, eventSourceId), hash, causedBy: identity,
                     observationState: EventObservationState.Initial, eventType, occurred, correlationId: correlationId.toString(),
                     causation: batchCausationChain.map(item => ({ type: item.type.name, occurred: item.occurred, properties: { ...item.properties } })),
                     tags: wire.Tags.map(tag => new Tag(tag))
@@ -408,6 +416,9 @@ export class InProcessEventSequence implements IEventSequence {
             options.concurrencyScope !== undefined || options.concurrencyScopes !== undefined || options.eventSourceId !== undefined) {
             throw this.unsupported('appendMany.options', this.id.value, 'Concurrency and unrecognized metadata are not fixture-backed.');
         }
+        if (options.subject !== undefined && options.subject !== null && typeof options.subject !== 'string') {
+            throw this.unsupported('appendMany.subject', this.id.value, 'Subject must be a string.');
+        }
         if (options.tags && (!Array.isArray(options.tags) || options.tags.some(tag => typeof tag !== 'string'))) {
             throw this.unsupported('appendMany.tags', this.id.value, 'Only plain string tags are fixture-backed.');
         }