@cratis/chronicle 6.43.0 → 6.45.0

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/types/modelBoundPropertyMetadata.ts

@@ -12,7 +12,7 @@ const finalizedMetadata = new FinalizationRegistry<WeakRef<object>>(reference =>
 
 export const modelBoundPropertyKeys = [
     'setFrom', 'setFromContext', 'setValue', 'addFrom', 'subtractFrom',
-    'increment', 'decrement', 'count', 'childrenFrom', 'join', 'fromEvery', 'fromAll'
+    'increment', 'decrement', 'count', 'childrenFrom', 'join', 'fromEvery', 'fromAll', 'fromAllEvents'
 ].map(name => `chronicle:projection:${name}`);
 
 /** Records a standard-decorated class with an event mapping on one of its fields. */