@cratis/chronicle 6.41.0 → 6.42.0

package/testing/ReadModelScenario.spec.ts

@@ -5,6 +5,7 @@ import { describe, expect, it } from 'vitest';
 import { ConceptAs, field, Guid } from '@cratis/fundamentals';
 import type { Constructor } from '@cratis/fundamentals';
 import { pii } from '../compliance/pii.js';
+import { subject } from '../compliance/subject.js';
 import { eventType } from '../events/eventTypeDecorator.js';
 import type { EventContext } from '../events/EventContext.js';
 import { fromEvent } from '../projections/modelBound/fromEvent.js';
@@ -219,6 +220,36 @@ describe('ReadModelScenario', () => {
         expect(await scenario.instance).toMatchObject({ subject: 'source-a' });
     });
 
+    it('maps a seeded event subject annotation to the projection Subject context', async () => {
+        class PersonalData {
+            @field(String) personId = 'person-a';
+        }
+        subject()(PersonalData.prototype, 'personId');
+        eventType('scenario-personal-data')(PersonalData);
+        class SubjectState { @field(String) id = ''; @field(String) subject = ''; }
+        fromEvent(PersonalData)(SubjectState);
+        setFromContext(PersonalData, 'subject')(SubjectState.prototype, 'subject');
+        const scenario = new ReadModelScenario(SubjectState, { ...artifacts, eventTypes: [PersonalData] });
+        scenario.given.forEventSource('source-a').events(new PersonalData());
+        expect(await scenario.instance).toMatchObject({ subject: 'person-a' });
+    });
+
+    it.each([undefined, null, '', ' \t\n', '\u0085\u2003'])('defaults an annotated subject %j to the event source', async value => {
+        class PersonalData {
+            // Keep null out of serialized content while exercising subject resolution.
+            get personId(): string | null | undefined { return value; }
+        }
+        field(String)(PersonalData.prototype, 'personId');
+        subject()(PersonalData.prototype, 'personId');
+        eventType('scenario-empty-subject')(PersonalData);
+        class SubjectState { @field(String) id = ''; @field(String) subject = ''; }
+        fromEvent(PersonalData)(SubjectState);
+        setFromContext(PersonalData, 'subject')(SubjectState.prototype, 'subject');
+        const scenario = new ReadModelScenario(SubjectState, { ...artifacts, eventTypes: [PersonalData] });
+        scenario.given.forEventSource('source-a').events(new PersonalData());
+        expect(await scenario.instance).toMatchObject({ subject: 'source-a' });
+    });
+
     it('defaults a projection Hash and CausedBy mapping to kernel sentinels when the seed omits them', async () => {
         class ContextDefaults { @field(String) id = ''; @field(String) hash = ''; @field(String) causedByName = ''; }
         setFromContext(ItemAdded, 'hash')(ContextDefaults.prototype, 'hash');

package/testing/ReadModelScenario.ts

@@ -7,6 +7,7 @@ import type { Constructor } from '@cratis/fundamentals';
 import { DefaultClientArtifactsProvider } from '../artifacts/DefaultClientArtifactsProvider.js';
 import type { IClientArtifactsProvider } from '../artifacts/IClientArtifactsProvider.js';
 import { getEventTypeMetadata } from '../events/eventTypeDecorator.js';
+import { resolveEventSubject } from '../compliance/resolveEventSubject.js';
 import { getFromEventMetadata } from '../projections/modelBound/fromEvent.js';
 import { getRemovedWithClassMetadata } from '../projections/modelBound/removedWith.js';
 import { getRemovedWithJoinClassMetadata } from '../projections/modelBound/removedWithJoin.js';
@@ -138,11 +139,14 @@ export class ReadModelScenario<TReadModel extends object> {
             if (!metadata) throw new Error(`Event '${event.constructor.name}' has no @eventType metadata.`);
             // The kernel delivers JSON objects, not instances of decorated event classes.
             const content: unknown = JSON.parse(JsonSerializer.serialize(event));
+            const subject = resolveEventSubject(event);
             this._events.push({
                 sourceId: id,
                 content,
                 context: {
                     eventSourceId: id,
+                    // Match the kernel's string.IsNullOrWhiteSpace, including U+0085 but not U+FEFF.
+                    subject: subject && !/^\p{White_Space}*$/u.test(subject) ? subject : id,
                     eventSourceType: 'Default',
                     eventStreamType: 'All',
                     eventStreamId: 'Default',

package/testing/for_EventScenario/when_appending_scoped_constraints/with_unproven_operations.spec.ts

@@ -83,7 +83,7 @@ describe('when a scoped append uses unsupported routes or metadata', () => {
                     await unsupported(() => scenario.appendMany('B', [new Claim('Beta')], options), `appendMany.${dimension}`);
                 }
             }
-            for (const options of [{ tags: [] }, { subject: '' }, { occurred: new Date() }, { correlationId: '00000000-0000-0000-0000-000000000001' },
+            for (const options of [{ tags: [] }, { occurred: new Date() }, { correlationId: '00000000-0000-0000-0000-000000000001' },
                 { concurrencyScopes: {} }, { eventSourceId: 'other' }, { arbitrary: true }]) {
                 await unsupported(() => scenario.append('B', new Claim('Beta'), options as AppendOptions), 'append.options');
             }

package/testing/for_ReadModelScenario/when_seeding_with_options/with_route_validation.spec.ts

@@ -25,7 +25,7 @@ describe('when read-model setup receives route options', () => {
     it('should reuse single-append rejection messages without collecting unsupported input', async () => {
         const scenario = create();
         const events = createEvents();
-        for (const value of [{ sourceType: ' ' }, { streamType: null }, { streamId: 1 }, { tags: [] }, { arbitrary: true }, null, []]) {
+        for (const value of [{ sourceType: ' ' }, { streamType: null }, { streamId: 1 }, null, []]) {
             const options = value as AppendOptions;
             const error = await rejection(() => events.append('A', new Claim('Other'), options));
             (await rejection(() => scenario.given.forEventSource('A', options).events(new Claim('Other')))).message.should.equal(error.message);
@@ -33,6 +33,16 @@ describe('when read-model setup receives route options', () => {
         ((await scenario.instance) === null).should.be.true;
     });
 
+    it('should list only supported seed options without collecting unsupported input', async () => {
+        const scenario = create();
+        for (const value of [{ tags: [] }, { arbitrary: true }, { subject: 'person-a' }]) {
+            const options = value as AppendOptions;
+            (await rejection(() => scenario.given.forEventSource('A', options).events(new Claim('Other')))).message.should.equal(
+                'UnsupportedEventSequenceOperation: append.options (Claim): Only sourceType, streamType, streamId options are supported for single append. Use a kernel-backed test.');
+        }
+        ((await scenario.instance) === null).should.be.true;
+    });
+
     it('should retain the unproven routed read-model boundary instead of simulating projection routing', async () => {
         const scenario = create();
         (() => scenario.given.forEventSource('A', route).events(new Claim('Other'))).should.throw(UnsupportedProjectionOperation, 'routed events');

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)' }

package/testing/singleAppendRoute.spec.ts

@@ -0,0 +1,19 @@
+// 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 } from 'vitest';
+import { singleAppendRoute } from './singleAppendRoute.js';
+
+chai.should();
+
+describe('when single-append routing rejects unsupported options', () => {
+    it('should list only routing options when subject is not allowed', () => {
+        (() => singleAppendRoute({ subject: 'person-a' }, 'SeededEvent'))
+            .should.throw('Only sourceType, streamType, streamId options are supported for single append.');
+    });
+
+    it('should include subject in the allowed options for single append', () => {
+        (() => singleAppendRoute({ tags: [] }, 'AppendedEvent', undefined, true))
+            .should.throw('Only sourceType, streamType, streamId, subject options are supported for single append.');
+    });
+});

package/testing/singleAppendRoute.ts

@@ -6,16 +6,21 @@ import { UnsupportedEventSequenceOperation } from './UnsupportedEventSequenceOpe
 
 /** The fixture-proven single-append route boundary, shared with read-model setup. */
 export function singleAppendRoute(options: AppendOptions | undefined, artifact: string,
-    unsupported = (operation: string, artifact: string, reason: string) => new UnsupportedEventSequenceOperation(operation, artifact, reason)
+    unsupported = (operation: string, artifact: string, reason: string) => new UnsupportedEventSequenceOperation(operation, artifact, reason),
+    allowSubject = false
 ): { sourceType: string; streamType: string; streamId: string } {
     if (options !== undefined && (!options || typeof options !== 'object' || Array.isArray(options))) {
         throw unsupported('append.options', artifact, 'Append options must be an object.');
     }
-    if (options && (Reflect.ownKeys(options).some(key => !['sourceType', 'streamType', 'streamId'].includes(String(key))) ||
-        options.correlationId !== undefined || options.subject !== undefined || options.occurred !== undefined ||
+    const allowed = ['sourceType', 'streamType', 'streamId', ...(allowSubject ? ['subject'] : [])];
+    if (options && (Reflect.ownKeys(options).some(key => !allowed.includes(String(key))) ||
+        options.correlationId !== undefined || (!allowSubject && options.subject !== undefined) || options.occurred !== undefined ||
         options.eventSourceId !== undefined || options.concurrencyScope !== undefined || options.tags !== undefined ||
         options.concurrencyScopes !== undefined)) {
-        throw unsupported('append.options', artifact, 'Only sourceType, streamType and streamId routing options are fixture-backed for single append.');
+        throw unsupported('append.options', artifact, `Only ${allowed.join(', ')} options are supported for single append.`);
+    }
+    if (options?.subject !== undefined && options.subject !== null && typeof options.subject !== 'string') {
+        throw unsupported('append.subject', artifact, 'Subject must be a string.');
     }
     const route = { sourceType: options?.sourceType, streamType: options?.streamType, streamId: options?.streamId };
     for (const [name, value] of Object.entries(route)) {