@cratis/chronicle 6.44.0 → 6.46.0

package/projections/declarative/for_CompositeKeyBuilder/when_typing_constant_parts.standard.spec.ts

@@ -0,0 +1,43 @@
+// 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 { CompositeKeyBuilder, type ICompositeKeyBuilder } from '../index.js';
+
+chai.should();
+
+class Key {
+    number!: number;
+    text!: string;
+    nullable!: string | null;
+    sourceNumber!: number;
+}
+class Changed { number!: number; }
+
+// Checked by test:standard-types. Do not execute invalid configurations at runtime.
+function rejectMismatchedConstants(builder: ICompositeKeyBuilder<Key, Changed>): void {
+    // @ts-expect-error A number key part cannot receive a string constant.
+    builder.set(key => key.number).toValue('orders');
+    // @ts-expect-error A string key part cannot receive a number constant.
+    builder.set(key => key.text).toValue(42);
+    // @ts-expect-error Null requires a nullable key part.
+    builder.set(key => key.text).toValue(null);
+}
+
+function rejectOnConcreteBuilder(builder: CompositeKeyBuilder<Key, Changed>): void {
+    // @ts-expect-error The concrete overload must not fall back to an untyped accessor.
+    builder.set(key => key.number).toValue('orders');
+}
+void rejectMismatchedConstants;
+void rejectOnConcreteBuilder;
+
+describe('when typing constant composite parts', () => {
+    it('should accept selected property types and preserve fluent chaining', () => {
+        const builder: ICompositeKeyBuilder<Key, Changed> = new CompositeKeyBuilder<Key, Changed>();
+        builder.set(key => key.number).toValue(42)
+            .set(key => key.text).toValue('orders')
+            .set(key => key.nullable).toValue(null)
+            .set(key => key.sourceNumber, event => event.number);
+        builder.build().should.equal('$composite(number=$value(42),text=$value(orders),nullable=$null,sourceNumber=number)');
+    });
+});

package/projections/declarative/index.ts

@@ -26,6 +26,7 @@ export type { IJoinBuilder } from './IJoinBuilder.js';
 export type { IFromEveryBuilder } from './IFromEveryBuilder.js';
 export type { IReadModelPropertiesBuilder } from './IReadModelPropertiesBuilder.js';
 export type { ICompositeKeyBuilder } from './ICompositeKeyBuilder.js';
+export type { ICompositeKeySetBuilder } from './ICompositeKeySetBuilder.js';
 export type { ISetBuilder } from './ISetBuilder.js';
 export type { IAllSetBuilder } from './IAllSetBuilder.js';
 export type { IAddBuilder } from './IAddBuilder.js';

package/reactors/ReactorDelivery.ts

@@ -0,0 +1,32 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Identifies one event delivered to one reactor partition. Handlers receive this as their
+ * fourth argument, after the event, EventContext and ReactorServices.
+ *
+ * The identity is stable across retries and replay. It is not exactly-once delivery:
+ * Chronicle stores no receipt and does not know whether an application's side effect completed.
+ */
+export class ReactorDelivery {
+    constructor(
+        readonly reactor: string,
+        readonly eventStore: string,
+        readonly namespace: string,
+        readonly eventSequence: string,
+        readonly partition: string,
+        readonly sequenceNumber: bigint
+    ) {
+        Object.freeze(this);
+    }
+
+    /**
+     * Application-owned receipt key, matching .NET's ReactorDelivery.Id.Value format.
+     * Components are joined with '#', without escaping or hashing. Persisted keys depend
+     * on stable reactor, store, namespace and event-sequence identifiers.
+     */
+    get id(): string {
+        return [this.reactor, this.eventStore, this.namespace, this.eventSequence,
+            this.partition, this.sequenceNumber.toString()].join('#');
+    }
+}

package/reactors/ReactorDispatcher.ts

@@ -14,6 +14,7 @@ import { getInstanceMethods } from '../observation/getInstanceMethods.js';
 import { isOnceOnly } from './onceOnly.js';
 import { getReplayEventType } from './replay.js';
 import type { ReactorServices } from './ReactorServices.js';
+import type { ReactorDelivery } from './ReactorDelivery.js';
 
 /** Internal handler catalog shared by live observations and in-process deliveries. */
 export interface ReactorEventTypeEntry {
@@ -83,9 +84,9 @@ export function selectReactorHandler(entries: readonly ReactorEventTypeEntry[],
 /** Handler and returned effects execute in the same production activation boundary. */
 export async function invokeReactorHandler(artifact: ActivatedArtifact<Record<string, Function>>, methodName: string,
     content: Record<string, unknown>, context: EventContext, services: ReactorServices | undefined,
-    handleResult: (value: unknown) => Promise<void>): Promise<void> {
+    handleResult: (value: unknown) => Promise<void>, delivery: ReactorDelivery): Promise<void> {
     await runActivated(artifact, async () => {
-        const result = await artifact.instance[methodName](content, context, services);
+        const result = await artifact.instance[methodName](content, context, services, delivery);
         await handleResult(result);
     }, { delivery: ArtifactDelivery.Events, eventContext: context, methodName });
 }

package/reactors/Reactors.ts

@@ -24,6 +24,7 @@ import { getReactorEventTypes, selectReactorHandler, invokeReactorHandler } from
 import type { ReactorEventTypeEntry } from './ReactorDispatcher.js';
 import type { ReactorResultHandler } from './ReactorResultHandler.js';
 import type { ReactorServices } from './ReactorServices.js';
+import { ReactorDelivery } from './ReactorDelivery.js';
 import type { IEventStore } from '../IEventStore.js';
 import type { ClientArtifactsActivator } from '../artifacts/ClientArtifactsActivator.js';
 import type { ActivatedArtifact } from '../artifacts/ActivatedArtifact.js';
@@ -375,7 +376,10 @@ export class Reactors implements IReactors {
 
                             await invokeReactorHandler(artifact, methodName, content, context, services, result =>
                                 dispatchReactorSideEffects(this._eventLog, result, context, reactorType as Function,
-                                    this._eventStoreName, this._namespace, this._resultHandler));
+                                    this._eventStoreName, this._namespace, this._resultHandler),
+                                new ReactorDelivery(id, context.eventStore ?? this._eventStoreName,
+                                    context.namespace ?? this._namespace, eventSequenceId,
+                                    context.eventSourceId, context.sequenceNumber));
 
                             lastSuccessfullyObservedEvent = event.Context!.SequenceNumber;
                         } catch (err) {

package/reactors/for_ReactorDelivery/when_comparing_deliveries.spec.ts

@@ -0,0 +1,27 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { ReactorDelivery } from '../index.js';
+
+chai.should();
+
+const components = ['order-confirmations', 'orders', 'default', 'event-log', 'order-42', 7n] as const;
+for (const [name, replacement] of [
+    ['reactor', 'shipment-notifications'], ['event store', 'billing'], ['namespace', 'another-tenant'],
+    ['event sequence', 'inbox-upstream'], ['partition', 'order-43'], ['sequence number', 8n]
+] as const) {
+    describe(`when comparing deliveries differing only in ${name}`, () => {
+        let original: ReactorDelivery;
+        let different: ReactorDelivery;
+        beforeEach(() => {
+            original = new ReactorDelivery(...components);
+            const changed: [string, string, string, string, string, bigint] = [...components];
+            const index = ['reactor', 'event store', 'namespace', 'event sequence', 'partition', 'sequence number'].indexOf(name);
+            if (typeof replacement === 'bigint') changed[5] = replacement;
+            else changed[index as 0 | 1 | 2 | 3 | 4] = replacement;
+            different = new ReactorDelivery(...changed);
+        });
+        it('should produce a distinct receipt key', () => { different.id.should.not.equal(original.id); });
+    });
+}

package/reactors/for_ReactorDelivery/when_rendering_a_receipt_key.spec.ts

@@ -0,0 +1,33 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { ReactorDelivery } from '../index.js';
+
+chai.should();
+
+describe('when rendering a delivery as an application receipt key', () => {
+    let delivery: ReactorDelivery;
+    beforeEach(() => {
+        delivery = new ReactorDelivery('Cratis.Chronicle.Reactors.for_ReactorDelivery.OrderConfirmations',
+            'orders', 'default', 'event-log', 'order-42', 7n);
+    });
+    it('should match the .NET v19.26.2 receipt format', () => {
+        delivery.id.should.equal('Cratis.Chronicle.Reactors.for_ReactorDelivery.OrderConfirmations#orders#default#event-log#order-42#7');
+    });
+    it('should render the same key for equal components in a new instance', () => {
+        new ReactorDelivery(delivery.reactor, delivery.eventStore, delivery.namespace,
+            delivery.eventSequence, delivery.partition, delivery.sequenceNumber).id.should.equal(delivery.id);
+    });
+    it('should preserve sequence numbers above the JavaScript safe integer range', () => {
+        new ReactorDelivery('orders', 'store', 'tenant', 'event-log', 'order-42', 18446744073709551615n)
+            .id.should.equal('orders#store#tenant#event-log#order-42#18446744073709551615');
+    });
+    it('should preserve .NET delimiter behavior without escaping or hashing', () => {
+        new ReactorDelivery('orders', '', 'tenant#one', 'event-log', 'order-42', 0n)
+            .id.should.equal('orders##tenant#one#event-log#order-42#0');
+    });
+    it('should keep the identity immutable during handling', () => {
+        Object.isFrozen(delivery).should.be.true;
+    });
+});

package/reactors/for_Reactors/given/deliver_to_reactor.ts

@@ -0,0 +1,47 @@
+// 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 { ReplayState, type EventContext, type ReactorMessage } from '@cratis/chronicle.contracts';
+import type { IClientArtifactsProvider } from '../../../artifacts/index.js';
+import type { ClientArtifactsActivator } from '../../../artifacts/ClientArtifactsActivator.js';
+import type { ChronicleConnection } from '../../../connection/index.js';
+import { ConnectionLifecycle } from '../../../connection/ConnectionLifecycle.js';
+import type { IEventLog } from '../../../eventSequences/IEventLog.js';
+import type { IEventStore } from '../../../IEventStore.js';
+import { Reactors } from '../../index.js';
+
+/** Deliver through the production observation stream without a kernel. */
+export async function deliverToReactor(reactorType: Constructor, eventType: Constructor,
+    contexts: readonly EventContext[], artifactActivator?: ClientArtifactsActivator,
+    eventStore = 'orders', namespace = 'default'): Promise<ReactorMessage[]> {
+    const lifecycle = new ConnectionLifecycle();
+    const results: ReactorMessage[] = [];
+    let finish!: () => void;
+    const finished = new Promise<void>(resolve => { finish = resolve; });
+    async function* stream(queue: AsyncIterable<ReactorMessage>) {
+        const messages = queue[Symbol.asyncIterator]();
+        await messages.next();
+        try {
+            for (const context of contexts) {
+                yield { Events: [{ Content: '{}', Context: context }], Partition: context.EventSourceId,
+                    ReplayState: ReplayState.REPLAY_STATE_None, InitialState: '' };
+                results.push((await messages.next()).value!);
+            }
+        } finally {
+            await lifecycle.disconnected(error => { throw error; });
+            finish();
+        }
+    }
+    const reactors = new Reactors({ reactors: [reactorType], eventTypes: [eventType] } as unknown as IClientArtifactsProvider,
+        { reactors: { observe: stream } } as unknown as ChronicleConnection,
+        eventStore, namespace, lifecycle, {} as IEventLog, undefined,
+        { readModels: {} } as IEventStore, artifactActivator);
+    try {
+        await reactors.register();
+        await finished;
+        return results;
+    } finally {
+        reactors.dispose();
+    }
+}

package/reactors/for_Reactors/when_delivering_a_stable_identity.spec.ts

@@ -0,0 +1,66 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { EventContext as ContractEventContext, EventObservationState, EventType, ObservationState } from '@cratis/chronicle.contracts';
+import type { EventContext } from '../../events/EventContext.js';
+import { eventType } from '../../events/eventTypeDecorator.js';
+import type { ClientArtifactsActivator } from '../../artifacts/ClientArtifactsActivator.js';
+import { handles, reactor, ReactorDelivery, replay, type ReactorServices } from '../index.js';
+import { deliverToReactor } from './given/deliver_to_reactor.js';
+
+chai.should();
+
+@eventType('delivery-order-placed')
+class OrderPlaced {}
+
+for (const activated of [false, true]) {
+    describe(`when a ${activated ? 'activated' : 'default'} reactor receives a retry and replay`, () => {
+        let deliveries: ReactorDelivery[];
+        let states: ObservationState[];
+        let contexts: EventContext[];
+        let services: ReactorServices[];
+        beforeEach(async () => {
+            deliveries = [];
+            contexts = [];
+            services = [];
+            @reactor('order-confirmations', 'inbox-upstream')
+            class OrderConfirmations {
+                @handles(OrderPlaced)
+                confirm(_event: OrderPlaced, context: EventContext, reactorServices: ReactorServices, delivery: ReactorDelivery) {
+                    contexts.push(context);
+                    services.push(reactorServices);
+                    deliveries.push(delivery);
+                    if (deliveries.length === 1) throw new Error('failed after side effect');
+                }
+                @replay(OrderPlaced)
+                restore(event: OrderPlaced, context: EventContext, reactorServices: ReactorServices, delivery: ReactorDelivery) {
+                    this.confirm(event, context, reactorServices, delivery);
+                }
+            }
+            const context = ContractEventContext.fromPartial({ EventType: EventType.fromPartial({ Id: 'delivery-order-placed', Generation: 1 }),
+                EventStore: 'source-store', Namespace: 'source-tenant', EventSourceId: 'order-42',
+                SequenceNumber: 9007199254740993n, ObservationState: EventObservationState.Initial });
+            const activator: ClientArtifactsActivator | undefined = activated ? type => ({ instance: new type() }) : undefined;
+            const results = await deliverToReactor(OrderConfirmations, OrderPlaced,
+                [context, { ...context }, { ...context, ObservationState: EventObservationState.Replay }], activator);
+            states = results.map(result => result.Content!.Value1!.State);
+        });
+        it('should preserve the identity through failed delivery, retry and a separate replay handler', () => {
+            deliveries.map(delivery => delivery.id).should.deep.equal(Array(3).fill(
+                'order-confirmations#source-store#source-tenant#inbox-upstream#order-42#9007199254740993'));
+        });
+        it('should expose all six components from the observed event and reactor', () => {
+            deliveries[0].should.deep.equal(new ReactorDelivery('order-confirmations', 'source-store', 'source-tenant',
+                'inbox-upstream', 'order-42', 9007199254740993n));
+        });
+        it('should preserve existing context and services arguments', () => {
+            contexts.map(context => context.observationState).should.deep.equal([
+                EventObservationState.Initial, EventObservationState.Initial, EventObservationState.Replay]);
+            services.every(service => service.eventStore.readModels === service.readModels).should.be.true;
+        });
+        it('should still report the handler failure and subsequent successes', () => {
+            states.should.deep.equal([ObservationState.Failed, ObservationState.Success, ObservationState.Success]);
+        });
+    });
+}

package/reactors/index.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 export { ReactorId } from './ReactorId.js';
+export { ReactorDelivery } from './ReactorDelivery.js';
 export { reactor, getReactorMetadata, isReactor } from './reactor.js';
 export { handles } from '../events/handles.js';
 export { onceOnly } from './onceOnly.js';

package/testing/ReactorScenario.ts

@@ -25,6 +25,7 @@ import { createHandlerInstanceValidator } from '../observation/createHandlerInst
 import { getReactorMetadata } from '../reactors/reactor.js';
 import { normalizeReactorSideEffects } from '../reactors/ReactorSideEffects.js';
 import type { ReactorServices } from '../reactors/ReactorServices.js';
+import { ReactorDelivery } from '../reactors/ReactorDelivery.js';
 import { EventScenario } from './EventScenario.js';
 import type { ReactorDeliveryResult } from './ReactorDeliveryResult.js';
 import type { ReactorScenarioOptions } from './ReactorScenarioOptions.js';
@@ -239,7 +240,10 @@ export class ReactorScenario {
                     // A swallowed unsupported call fails this event like a throwing handler: nothing is recorded.
                     this.throwIfViolated(delivery);
                     return this.record(result, event.context, selection.methodName!, deliveryIndex);
-                });
+                }, new ReactorDelivery(getReactorMetadata(this._reactor)!.id.value,
+                    event.context.eventStore ?? this._options.eventStore ?? 'test-event-store',
+                    event.context.namespace ?? this._options.namespace ?? 'default', 'event-log',
+                    event.context.eventSourceId, event.context.sequenceNumber));
                 this.throwIfViolated(delivery);
                 handled.push(event.context);
             }

package/testing/for_ReactorScenario/when_receiving_a_delivery_identity.spec.ts

@@ -0,0 +1,68 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { field } from '@cratis/fundamentals';
+import { EventContext as ContractEventContext, EventType as ContractEventType, ObservationState } from '@cratis/chronicle.contracts';
+import type { EventContext } from '../../events/EventContext.js';
+import { eventType } from '../../events/eventTypeDecorator.js';
+import { ReactorDelivery, reactor, type ReactorServices } from '../../reactors/index.js';
+import { deliverToReactor } from '../../reactors/for_Reactors/given/deliver_to_reactor.js';
+import { ReactorScenario } from '../index.js';
+import type { ClientArtifactsActivator } from '../../artifacts/ClientArtifactsActivator.js';
+
+chai.should();
+
+@eventType('scenario-delivery-order-placed')
+class OrderPlaced {
+    @field(String) readonly name: string;
+    constructor(name = '') { this.name = name; }
+}
+
+for (const activated of [false, true]) {
+    describe(`when a ${activated ? 'activated' : 'default'} scenario reactor receives a delivery identity`, () => {
+        let scenarioDeliveries: ReactorDelivery[];
+        let productionDeliveries: ReactorDelivery[];
+        let contexts: EventContext[];
+        let states: ObservationState[];
+        beforeEach(async () => {
+            let deliveries: ReactorDelivery[] = [];
+            contexts = [];
+            @reactor('order-confirmations')
+            class OrderConfirmations {
+                orderPlaced(_event: OrderPlaced, context: EventContext, services: ReactorServices, delivery: ReactorDelivery) {
+                    (services.eventStore.readModels === services.readModels).should.be.true;
+                    contexts.push(context);
+                    deliveries.push(delivery);
+                }
+            }
+            const activator: ClientArtifactsActivator | undefined = activated ? type => ({ instance: new type() }) : undefined;
+            const scenario = new ReactorScenario(OrderConfirmations, {
+                artifacts: { eventTypes: [OrderPlaced] }, constraints: 'disabled', artifactActivator: activator });
+            await scenario.given.forEventSource('order-42').events(new OrderPlaced('first'));
+            await scenario.when.forEventSource('order-43').events(new OrderPlaced('second'));
+            scenarioDeliveries = deliveries;
+            const wireContexts = contexts.map(context => ContractEventContext.fromPartial({
+                EventType: ContractEventType.fromPartial({ Id: 'scenario-delivery-order-placed', Generation: 1 }),
+                EventStore: context.eventStore, Namespace: context.namespace,
+                EventSourceId: context.eventSourceId, SequenceNumber: context.sequenceNumber,
+                ObservationState: context.observationState
+            }));
+            deliveries = [];
+            const results = await deliverToReactor(OrderConfirmations, OrderPlaced, wireContexts, activator,
+                'test-event-store', 'default');
+            productionDeliveries = deliveries;
+            states = results.map(result => result.Content!.Value1!.State);
+        });
+        it('should supply the same identity as the production observation path', () => {
+            scenarioDeliveries.should.deep.equal(productionDeliveries);
+            scenarioDeliveries.map(delivery => delivery.id).should.deep.equal(productionDeliveries.map(delivery => delivery.id));
+            states.should.deep.equal([ObservationState.Success, ObservationState.Success]);
+        });
+        it('should use the fixture store, namespace, partition and committed sequence number', () => {
+            scenarioDeliveries.map(delivery => delivery.id).should.deep.equal([
+                'order-confirmations#test-event-store#default#event-log#order-42#0',
+                'order-confirmations#test-event-store#default#event-log#order-43#1']);
+        });
+    });
+}

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 }> = {
+    'composite-parent-key-without-constant.json': { type: 'UnsupportedProjectionOperation', message: 'only a lowercase id with a fixture-backed string, GUID, or number/double schema' },
+    'composite-child-join-key-expression-parts.json': { type: 'UnsupportedProjectionOperation', message: 'only a lowercase id with a fixture-backed string, GUID, or number/double schema' },
+    'composite-key-expression-parts.json': { type: 'UnsupportedProjectionOperation', message: 'only a lowercase id with a fixture-backed string, GUID, or number/double schema' },
+    'composite-parent-key-expression-parts.json': { type: 'UnsupportedProjectionOperation', message: 'only a lowercase id with a fixture-backed string, GUID, or number/double schema' },
+    'composite-join-key-expression-parts.json': { type: 'UnsupportedProjectionOperation', message: 'join keys other than $eventSourceId' },
     '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' },

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

@@ -0,0 +1,40 @@
+// 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 { chai, describe, it } from 'vitest';
+import type { ICompositeKeyBuilder } from '../../../projections/declarative/ICompositeKeyBuilder.js';
+import { ProjectionCapabilities } from '../ProjectionCapabilities.js';
+import { UnsupportedProjectionOperation } from '../UnsupportedProjectionOperation.js';
+import { Changed } from './given/Changed.js';
+import { Removed } from './given/Removed.js';
+import { compileDeclarative } from './given/compile.js';
+
+chai.should();
+
+for (const source of ['event property', 'context', 'source id', 'constant'] as const) {
+    for (const kind of ['root', 'parent', 'join'] as const) {
+        describe(`when validating a ${kind} composite key with a ${source} part before replay`, () => {
+            it('should reject the composite key rather than evaluate unproven semantics', () => {
+                const configure = <TEvent>(key: ICompositeKeyBuilder<{ part: string }, TEvent>) => {
+                    const part = key.set(target => target.part);
+                    if (source === 'context') return part.toEventContextProperty('subject');
+                    if (source === 'source id') return part.toEventSourceId();
+                    if (source === 'constant') return part.toValue('fixed');
+                    return part.to(event => (event as { name: string }).name);
+                };
+                const { compiled, definition } = compileDeclarative(builder => {
+                    if (kind === 'root') builder.from(Changed, from => from.usingCompositeKey(configure));
+                    if (kind === 'parent') builder.from(Changed, from => from.usingParentCompositeKey(configure));
+                    if (kind === 'join') builder
+                        .from(Changed, from => from.set(model => model.state).to(event => event.name))
+                        .join(Removed, join => join.on(model => model.state).usingCompositeKey(configure));
+                });
+                const section = kind === 'join' ? 'Join[capability-removed:1].Key'
+                    : kind === 'parent' ? 'From[capability-changed:1].ParentKey' : 'From[capability-changed:1].Key';
+                (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation)
+                    .with.property('message').that.includes(section);
+            });
+        });
+    }
+}