@cratis/chronicle 6.41.1 → 6.42.1

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/for_ProjectionDefinitionCompiler/when_compiling_tags/with_legacy_decorators.legacy.spec.ts

@@ -0,0 +1,87 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { chai, describe, it, vi } from 'vitest';
+import type { IClientArtifactsProvider } from '../../../artifacts/index.js';
+import type { ChronicleConnection } from '../../../connection/index.js';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import { getTagsFor, tag, tags } from '../../../events/tagDecorator.js';
+import { ReadModelScenario } from '../../../testing/ReadModelScenario.js';
+import type { IProjectionBuilderFor } from '../../declarative/IProjectionBuilderFor.js';
+import { projection } from '../../declarative/projection.js';
+import { fromEvent } from '../../modelBound/fromEvent.js';
+import { ProjectionDefinitionCompiler } from '../../ProjectionDefinitionCompiler.js';
+import { Projections } from '../../Projections.js';
+
+chai.should();
+
+@eventType('legacy-projection-tags-renamed')
+class Renamed {
+    name = 'updated';
+}
+function createArtifacts(modelBound: boolean, values: string[] = []) {
+    @tag(...(modelBound ? values : ['read-model-only']))
+    class Model {
+        static readonly readModelId = 'legacy-projection-tags-model';
+        id = '';
+        name = '';
+    }
+    @projection('legacy-projection-tags-projection', Model)
+    @tag(...(modelBound ? [] : values))
+    class ModelProjection {
+        define(builder: IProjectionBuilderFor<Model>): void {
+            builder.from(Renamed);
+        }
+    }
+    if (modelBound) fromEvent(Renamed)(Model);
+    const observer = modelBound ? Model : ModelProjection;
+    const artifacts: IClientArtifactsProvider = {
+        eventTypes: [Renamed], readModels: [Model], projections: modelBound ? [] : [ModelProjection],
+        reducers: [], reactors: [], globalForHandlers: [], seeders: [], constraints: [], webhooks: [], eventTypeMigrations: []
+    };
+    const compile = () => new ProjectionDefinitionCompiler(artifacts, 'test-sink')
+        .compile(artifacts.projections, modelBound ? [Model] : []).definitions[0];
+    return { artifacts, observer, Model, compile };
+}
+
+for (const modelBound of [false, true]) {
+    describe(`when compiling tags on a legacy ${modelBound ? 'model-bound read model' : 'declarative projection class'}`, () => {
+        it('should send accumulated distinct observer labels to the kernel in stable order', async () => {
+            const { artifacts, observer } = createArtifacts(modelBound, ['reporting', 'analytics']);
+            tags('reporting', 'audit')(observer);
+            tag('analytics')(observer);
+            const register = vi.fn().mockResolvedValue({});
+            const connection = { projections: { register }, readModels: { registerMany: vi.fn().mockResolvedValue({}) } } as unknown as ChronicleConnection;
+            await new Projections('store', 'namespace', connection, artifacts, 'test-sink').register();
+            const request = register.mock.calls[0][0] as { Projections: { Tags: string[] }[] };
+            request.Projections[0].Tags.should.deep.equal(['analytics', 'audit', 'reporting']);
+        });
+
+        it('should keep an untagged observer empty without borrowing declarative read-model labels', () => {
+            createArtifacts(modelBound).compile().Tags.should.deep.equal([]);
+        });
+
+        it('should hash the same tag set identically regardless of declaration order and duplicates', () => {
+            const first = createArtifacts(modelBound, ['reporting', 'analytics']);
+            tags('reporting')(first.observer);
+            const second = createArtifacts(modelBound, ['analytics', 'reporting', 'analytics']);
+            first.compile().LastUpdated!.Value.should.equal(second.compile().LastUpdated!.Value);
+            first.compile().LastUpdated!.Value.should.equal(first.compile().LastUpdated!.Value);
+        });
+
+        it('should include tag changes in the definition hash without reordering metadata', () => {
+            const { compile, observer } = createArtifacts(modelBound, ['reporting', 'analytics']);
+            const previous = compile().LastUpdated!.Value;
+            getTagsFor(observer).map(value => value.value).should.deep.equal(['reporting', 'analytics']);
+            tag('audit')(observer);
+            compile().LastUpdated!.Value.should.not.equal(previous);
+        });
+
+        it('should not filter untagged events in the in-process read-model scenario', async () => {
+            const { Model, artifacts } = createArtifacts(modelBound, ['analytics']);
+            const scenario = new ReadModelScenario(Model, artifacts);
+            scenario.given.forEventSource('source').events(new Renamed());
+            (await scenario.instance)!.name.should.equal('updated');
+        });
+    });
+}

package/projections/for_ProjectionDefinitionCompiler/when_compiling_tags/with_standard_decorators.standard.spec.ts

@@ -0,0 +1,77 @@
+// 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, vi } from 'vitest';
+import type { IClientArtifactsProvider } from '../../../artifacts/index.js';
+import type { ChronicleConnection } from '../../../connection/index.js';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import { getTagsFor, tag, tags } from '../../../events/tagDecorator.js';
+import { ReadModelScenario } from '../../../testing/ReadModelScenario.js';
+import type { IProjectionBuilderFor } from '../../declarative/IProjectionBuilderFor.js';
+import { projection } from '../../declarative/projection.js';
+import { fromEvent } from '../../modelBound/fromEvent.js';
+import { ProjectionDefinitionCompiler } from '../../ProjectionDefinitionCompiler.js';
+import { Projections } from '../../Projections.js';
+
+chai.should();
+
+@eventType('standard-projection-tags-renamed')
+class Renamed {
+    @field(String) name = 'updated';
+}
+
+@tag('read-model-only')
+class DeclarativeModel {
+    @field(String) id = '';
+    @field(String) name = '';
+}
+
+@projection('standard-projection-tags-projection', DeclarativeModel)
+@tag('analytics', 'reporting')
+@tags('reporting', 'audit')
+class ModelProjection {
+    define(builder: IProjectionBuilderFor<DeclarativeModel>): void {
+        builder.from(Renamed);
+    }
+}
+
+@fromEvent(Renamed)
+@tags('analytics', 'reporting')
+@tag('reporting', 'audit')
+class ModelBound {
+    @field(String) id = '';
+    @field(String) name = '';
+}
+
+for (const modelBound of [false, true]) {
+    describe(`when compiling tags on a standard ${modelBound ? 'model-bound read model' : 'declarative projection class'}`, () => {
+        const model = modelBound ? ModelBound : DeclarativeModel;
+        const observer = modelBound ? ModelBound : ModelProjection;
+        const artifacts: IClientArtifactsProvider = {
+            eventTypes: [Renamed], readModels: [model], projections: modelBound ? [] : [ModelProjection],
+            reactors: [], reducers: [], globalForHandlers: [], seeders: [], constraints: [], webhooks: [], eventTypeMigrations: []
+        };
+        const compile = () => new ProjectionDefinitionCompiler(artifacts, 'test-sink')
+            .compile(artifacts.projections, modelBound ? [ModelBound] : []).definitions[0];
+
+        it('should register sorted distinct tags using both class decorator spellings', async () => {
+            const register = vi.fn().mockResolvedValue({});
+            const connection = { projections: { register }, readModels: { registerMany: vi.fn().mockResolvedValue({}) } } as unknown as ChronicleConnection;
+            await new Projections('store', 'namespace', connection, artifacts, 'test-sink').register();
+            const request = register.mock.calls[0][0] as { Projections: { Tags: string[] }[] };
+            request.Projections[0].Tags.should.deep.equal(['analytics', 'audit', 'reporting']);
+        });
+
+        it('should retain a deterministic hash and leave decorator metadata untouched', () => {
+            compile().LastUpdated!.Value.should.equal(compile().LastUpdated!.Value);
+            getTagsFor(observer).map(value => value.value).should.deep.equal(['reporting', 'audit', 'analytics']);
+        });
+
+        it('should still evaluate untagged events through the shared compiler', async () => {
+            const scenario = new ReadModelScenario(model, artifacts);
+            scenario.given.forEventSource('source').events(new Renamed());
+            (await scenario.instance)!.name.should.equal('updated');
+        });
+    });
+}

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/reactors/for_Reactors/against_a_kernel/when_replaying_once_only_reactors.integration.spec.ts

@@ -3,6 +3,7 @@
 
 import { randomUUID } from 'node:crypto';
 import { afterAll, beforeAll, chai, describe, it } from 'vitest';
+import { ObserverRunningState } from '@cratis/chronicle.contracts';
 import { field } from '@cratis/fundamentals';
 import { ChronicleClient } from '../../../ChronicleClient.js';
 import { ChronicleOptions } from '../../../ChronicleOptions.js';
@@ -52,9 +53,9 @@ const artifacts: IClientArtifactsProvider = {
     globalForHandlers: []
 };
 
-async function eventually(accept: () => boolean, timeoutMs = 30_000): Promise<void> {
+async function eventually(accept: () => boolean | Promise<boolean>, timeoutMs = 30_000): Promise<void> {
     const deadline = Date.now() + timeoutMs;
-    while (!accept()) {
+    while (!await accept()) {
         if (Date.now() > deadline) throw new Error('Timed out waiting for the kernel');
         await new Promise(resolve => setTimeout(resolve, 250));
     }
@@ -77,6 +78,18 @@ describe.skipIf(!connectionString && !process.env.CI)('when replaying reactors a
         EventSequenceId: 'event-log'
     });
 
+    const waitForActiveObservers = (lastHandledSequenceNumber?: bigint) => eventually(async () => {
+        const observers = await Promise.all(['OnceOnlyReactor', 'ReplayableReactor'].map(observerId =>
+            connection.observers.getObserverInformation({
+                EventStore: storeName,
+                Namespace: 'Default',
+                ObserverId: observerId,
+                EventSequenceId: 'event-log'
+            })));
+        return observers.every(observer => observer.IsSubscribed && observer.RunningState === ObserverRunningState.Active &&
+            (lastHandledSequenceNumber === undefined || observer.LastHandledEventSequenceNumber === lastHandledSequenceNumber));
+    }, 15_000);
+
     beforeAll(async () => {
         client = new ChronicleClient(ChronicleOptions.fromConnectionString(connectionString!, {
             discoveryPatterns: [],
@@ -85,8 +98,14 @@ describe.skipIf(!connectionString && !process.env.CI)('when replaying reactors a
         store = await client.getEventStore(storeName);
         connection = (store as unknown as { _connection: ChronicleConnection })._connection;
 
-        (await store.eventLog.append(randomUUID(), Object.assign(new ThingHappened(), { name: 'first' }))).isSuccess.should.be.true;
+        // Registration starts observation in the background. Append only after both subscriptions
+        // are active, so initial catch-up cannot race the explicit replay's state transition.
+        await waitForActiveObservers();
+        const appended = await store.eventLog.append(randomUUID(), Object.assign(new ThingHappened(), { name: 'first' }));
+        appended.isSuccess.should.be.true;
         await eventually(() => onceOnlyInvocations.length === 1 && replayableInvocations.length === 1);
+        // The handlers update their sinks before the kernel acknowledges delivery and records progress.
+        await waitForActiveObservers(appended.sequenceNumber.value);
 
         onceOnlyJobId = (await replay('OnceOnlyReactor')).JobId;
         replayableJobId = (await replay('ReplayableReactor')).JobId;

package/testing/projections/ProjectionReadModelProcessor.fixtures.spec.ts

@@ -38,6 +38,11 @@ const allFixtures = readdirSync(directory).filter(name => name.endsWith('.json')
     .map(name => ({ name, fixture: JSON.parse(readFileSync(new URL(name, directory), 'utf8')) as Fixture }));
 const fixtures = allFixtures.filter(({ fixture }) => fixture.kind === 'kernelSemantics');
 const guardErrors: Record<string, { type: string; message: string }> = {
+    'from-all-only.json': { type: 'UnsupportedProjectionOperation', message: 'subscribe-to-all projections require a kernel-backed test' },
+    'from-all-mixed.json': { type: 'UnsupportedProjectionOperation', message: 'subscribe-to-all projections require a kernel-backed test' },
+    'from-all-exclude-children.json': { type: 'UnsupportedProjectionOperation', message: 'subscribe-to-all projections require a kernel-backed test' },
+    'from-all-empty.json': { type: 'UnsupportedProjectionOperation', message: 'subscribe-to-all projections require a kernel-backed test' },
+    'from-every-restricted.json': { type: 'UnsupportedProjectionOperation', message: 'fromEvery/all subscriptions require a kernel-backed test' },
     'joins-custom-key.json': { type: 'UnsupportedProjectionOperation', message: 'join keys other than $eventSourceId' },
     'joins-initial-state.json': { type: 'UnsupportedProjectionOperation', message: 'joins with initial model state' },
     'arithmetic-string-operand.json': { type: 'UnsupportedProjectionOperation', message: 'arithmetic operands must have number/double' },

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

@@ -79,6 +79,8 @@ describe('when rejecting unsupported operations before any event is seeded', ()
         { name: 'removedWithJoin', define: builder => { builder.from(Changed).removedWithJoin(Removed); }, path: 'RemovedWithJoin[capability-removed:1] (.removedWithJoin)' },
         { name: 'removal key', define: builder => { builder.from(Removed).removedWith(Changed, removal => removal.usingKey(event => event.name)); }, path: 'RemovedWith[capability-changed:1].Key (.removedWith)' },
         { name: 'fromEvery', define: builder => { builder.from(Changed).fromEvery(all => all.set(model => model.name).toEventSourceId()); }, path: 'All (.fromEvery)' },
+        { name: 'fromAll', define: builder => { builder.fromAll(all => all.set(model => model.name).toEventSourceId()); }, path: 'SubscribesToAllEvents (.fromAll)' },
+        { name: 'empty fromAll', define: builder => { builder.fromAll(() => {}); }, path: 'SubscribesToAllEvents (.fromAll)' },
         { name: 'empty fromEvery', define: builder => { builder.from(Changed).fromEvery(all => all.excludeChildProjections()); }, path: 'All (.fromEvery)' },
         { name: 'passive', define: builder => { builder.from(Changed).passive(); }, path: 'IsActive (.passive)' },
         { name: 'event sequence', define: builder => { builder.from(Changed).fromEventSequence('custom'); }, path: 'EventSequenceId (.fromEventSequence)' }