@cratis/chronicle 5.1.0 → 6.1.0

package/eventSequences/for_EventSequence/when_reading/with_route_filters.spec.ts

@@ -0,0 +1,124 @@
+// 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, vi } from 'vitest';
+import { EventSequence, EventSequenceId } from '../../index';
+import { eventType } from '../../../events';
+import type { ChronicleConnection } from '../../../connection';
+import type { IUnitOfWorkManager } from '../../../transactions';
+
+chai.should();
+
+// The kernel resolves an append that carried no route to source type 'Default', stream type 'All' and
+// stream identifier 'Default', and treats an empty dimension on a read as "do not narrow". A client that
+// defaulted a read to the legacy 'Default' route would therefore return none of those events.
+class RouteReadRecorded {}
+eventType('RouteReadRecorded')(RouteReadRecorded);
+
+class RouteReadObserver {
+    routeReadRecorded(_event: RouteReadRecorded) {}
+}
+
+function createSequence() {
+    const tailSequenceNumber = vi.fn().mockResolvedValue({ Data: { SequenceNumber: 7n } });
+    const forEventSourceIdAndEventTypes = vi.fn().mockResolvedValue({ Data: [] });
+    const connection = { eventSequences: { tailSequenceNumber, forEventSourceIdAndEventTypes } } as unknown as ChronicleConnection;
+    return {
+        sequence: new EventSequence(EventSequenceId.eventLog, 'store', 'tenant', connection, {} as IUnitOfWorkManager),
+        tailSequenceNumber,
+        forEventSourceIdAndEventTypes
+    };
+}
+
+describe('when reading the tail sequence number without explicit routes', () => {
+    let request: { EventSourceType: string; EventStreamType: string; EventStreamId: string };
+    beforeEach(async () => {
+        const { sequence, tailSequenceNumber } = createSequence();
+        await sequence.getNextSequenceNumber();
+        request = tailSequenceNumber.mock.calls[0][0];
+    });
+    it('should not narrow the read to the legacy route', () => {
+        [request.EventSourceType, request.EventStreamType, request.EventStreamId].should.deep.equal(['', '', '']);
+    });
+});
+
+describe('when reading the tail sequence number with explicit routes', () => {
+    let request: { EventSourceType: string; EventStreamType: string; EventStreamId: string };
+    beforeEach(async () => {
+        const { sequence, tailSequenceNumber } = createSequence();
+        await sequence.getTailSequenceNumber(undefined, 'Default', 'Default', 'source');
+        request = tailSequenceNumber.mock.calls[0][0];
+    });
+    it('should send every supplied dimension unchanged', () => {
+        [request.EventSourceType, request.EventStreamType, request.EventStreamId].should.deep.equal(['Default', 'Default', 'source']);
+    });
+});
+
+describe('when reading the tail sequence number for an observer', () => {
+    let request: { EventSourceType: string; EventStreamType: string; EventStreamId: string; EventTypeIds: string };
+    beforeEach(async () => {
+        const { sequence, tailSequenceNumber } = createSequence();
+        await sequence.getTailSequenceNumberForObserver(RouteReadObserver);
+        request = tailSequenceNumber.mock.calls[0][0];
+    });
+    it('should not narrow the read to the legacy route', () => {
+        [request.EventSourceType, request.EventStreamType, request.EventStreamId].should.deep.equal(['', '', '']);
+    });
+    it('should still narrow to the event types the observer handles', () => {
+        request.EventTypeIds.should.equal('RouteReadRecorded');
+    });
+});
+
+describe('when reading events for an event source without an explicit stream type', () => {
+    let request: { EventStreamType: string; EventStreamId: string; EventSourceType: string };
+    beforeEach(async () => {
+        const { sequence, forEventSourceIdAndEventTypes } = createSequence();
+        await sequence.getForEventSourceIdAndEventTypes('source', [RouteReadRecorded]);
+        request = forEventSourceIdAndEventTypes.mock.calls[0][0];
+    });
+    it('should not hide events the kernel routed for an unrouted append', () => {
+        [request.EventStreamType, request.EventStreamId, request.EventSourceType].should.deep.equal(['', '', '']);
+    });
+});
+
+describe('when reading events for an event source with an explicit stream type', () => {
+    let request: { EventStreamType: string; EventStreamId: string };
+    beforeEach(async () => {
+        const { sequence, forEventSourceIdAndEventTypes } = createSequence();
+        await sequence.getForEventSourceIdAndEventTypes('source', [RouteReadRecorded], 'Default', 'source');
+        request = forEventSourceIdAndEventTypes.mock.calls[0][0];
+    });
+    it('should send the supplied stream scope unchanged', () => {
+        [request.EventStreamType, request.EventStreamId].should.deep.equal(['Default', 'source']);
+    });
+});
+
+// The event source type was accepted and dropped before it reached the request, so a caller narrowing by
+// it silently got every source type back. The specification above exercised this call with a stream scope
+// and never asserted on the source type, which is what kept the drop invisible. See Cratis/Chronicle#4049.
+describe('when reading events for an event source narrowed to an event source type', () => {
+    let request: { EventSourceType: string; EventStreamType: string; EventStreamId: string };
+    beforeEach(async () => {
+        const { sequence, forEventSourceIdAndEventTypes } = createSequence();
+        await sequence.getForEventSourceIdAndEventTypes('source', [RouteReadRecorded], undefined, undefined, 'Order');
+        request = forEventSourceIdAndEventTypes.mock.calls[0][0];
+    });
+    it('should send the event source type', () => {
+        request.EventSourceType.should.equal('Order');
+    });
+    it('should leave the stream dimensions unnarrowed', () => {
+        [request.EventStreamType, request.EventStreamId].should.deep.equal(['', '']);
+    });
+});
+
+describe('when reading events for an event source narrowed to every dimension', () => {
+    let request: { EventSourceType: string; EventStreamType: string; EventStreamId: string };
+    beforeEach(async () => {
+        const { sequence, forEventSourceIdAndEventTypes } = createSequence();
+        await sequence.getForEventSourceIdAndEventTypes('source', [RouteReadRecorded], 'Default', 'source', 'Order');
+        request = forEventSourceIdAndEventTypes.mock.calls[0][0];
+    });
+    it('should send every supplied dimension unchanged', () => {
+        [request.EventSourceType, request.EventStreamType, request.EventStreamId].should.deep.equal(['Order', 'Default', 'source']);
+    });
+});

package/events/CausationEntry.ts

@@ -5,6 +5,9 @@
  * Represents a single entry in the causation chain of an event.
  */
 export interface CausationEntry {
+    /** The occurrence time of the causing operation, when supplied by the kernel. */
+    readonly occurred?: Date;
+
     /** The type identifier of the causing operation. */
     readonly type: string;
 

package/events/EventContext.ts

@@ -4,6 +4,7 @@
 import { EventType } from './EventType';
 import { CausationEntry } from './CausationEntry';
 import { Tag } from './Tag';
+import type { Identity } from '../identity/Identity';
 
 /**
  * Represents contextual information about an appended event.
@@ -15,6 +16,33 @@ export interface EventContext {
     /** The unique identifier of the event source. */
     readonly eventSourceId: string;
 
+    /** The event store, when included by the kernel. */
+    readonly eventStore?: string;
+
+    /** The namespace, when included by the kernel. */
+    readonly namespace?: string;
+
+    /** The source type returned by the kernel. */
+    readonly eventSourceType?: string;
+
+    /** The stream type returned by the kernel. */
+    readonly eventStreamType?: string;
+
+    /** The stream identifier returned by the kernel. */
+    readonly eventStreamId?: string;
+
+    /** The compliance subject returned by the kernel. */
+    readonly subject?: string;
+
+    /** The persisted event hash. */
+    readonly hash?: string;
+
+    /** The identity responsible for the event. */
+    readonly causedBy?: Identity;
+
+    /** The observation state carried by the delivery. */
+    readonly observationState?: number;
+
     /** The type of the event. */
     readonly eventType: EventType;
 

package/events/WireEventContext.ts

@@ -0,0 +1,14 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { AppendedEventResponse } from '@cratis/chronicle.contracts';
+
+/** Shared metadata shape; generated services use distinct observation-state enum types. */
+export type WireEventContext = Omit<NonNullable<AppendedEventResponse['Context']>, 'ObservationState'> & {
+    /** Numeric wire value shared by the generated observation-state enums. */
+    ObservationState: number;
+    /** Store metadata is carried by observer deliveries, but not every read response. */
+    EventStore?: string;
+    /** Namespace metadata is carried by observer deliveries, but not every read response. */
+    Namespace?: string;
+};

package/events/for_EventContext/when_receiving/with_kernel_metadata.spec.ts

@@ -0,0 +1,109 @@
+// 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 ContractsEventContext, EventType as ContractsEventType } from '@cratis/chronicle.contracts';
+import type { IClientArtifactsProvider } from '../../../artifacts';
+import type { ChronicleConnection } from '../../../connection';
+import { ConnectionLifecycle } from '../../../connection/ConnectionLifecycle';
+import { toContractsGuid } from '../../../connection/Guid';
+import { EventSequence, EventSequenceId, EventSequenceNumber } from '../../../eventSequences';
+import type { IEventLog } from '../../../eventSequences';
+import { Reactors, reactor } from '../../../reactors';
+import { Reducers, reducer } from '../../../reducers';
+import type { IUnitOfWorkManager } from '../../../transactions';
+import { eventType } from '../../eventTypeDecorator';
+import type { EventContext } from '../../EventContext';
+import { Guid } from '@cratis/fundamentals';
+
+chai.should();
+class CanonicalMetadataRecorded {}
+eventType('CanonicalMetadataRecorded')(CanonicalMetadataRecorded);
+const correlationId = '12345678-1234-5678-9abc-123456789abc';
+const occurred = '2025-06-07T08:09:10.123Z';
+function wireEvent() {
+    return {
+        Context: ContractsEventContext.fromPartial({
+            EventType: ContractsEventType.fromPartial({ Id: 'CanonicalMetadataRecorded', Generation: 2, Tombstone: true }),
+            EventStore: 'store', Namespace: 'tenant',
+            SequenceNumber: 9007199254740993n, EventSourceId: 'source', EventSourceType: 'Source',
+            EventStreamType: 'Stream', EventStreamId: 'stream-id', Subject: 'subject', Hash: 'persisted-hash',
+            Occurred: { Value: occurred }, CorrelationId: toContractsGuid(Guid.as(correlationId)),
+            Tags: ['one', 'two'], ObservationState: 1,
+            Causation: [{ Type: 'command', Occurred: { Value: occurred }, Properties: { key: 'value' } }],
+            CausedBy: { Subject: 'actor', Name: 'Actor', UserName: 'actor-name', OnBehalfOf: { Subject: 'delegate', Name: 'Delegate' } }
+        }),
+        Content: '{}'
+    };
+}
+
+async function receiveContext(kind: string): Promise<EventContext> {
+    if (kind === 'read') {
+        const connection = { eventSequences: { fromSequenceNumber: async () => ({ Data: [wireEvent()] }) } } as unknown as ChronicleConnection;
+        const sequence = new EventSequence(EventSequenceId.eventLog, 'store', 'tenant', connection, {} as IUnitOfWorkManager);
+        return (await sequence.getFromSequenceNumber(EventSequenceNumber.first))[0].context;
+    }
+
+    let received: EventContext | undefined;
+    class CapturingReactor { canonicalMetadataRecorded(_event: object, context: EventContext) { received = context; } }
+    class State { count = 0; }
+    class CapturingReducer {
+        canonicalMetadataRecorded(_event: object, _state: State | undefined, context: EventContext) {
+            received = context;
+            return { count: 1 };
+        }
+    }
+    reactor('metadata-reactor')(CapturingReactor);
+    reducer('metadata-reducer', undefined, State)(CapturingReducer);
+    const lifecycle = new ConnectionLifecycle();
+    let finish!: () => void;
+    const finished = new Promise<void>(resolve => { finish = resolve; });
+    async function* observe(queue: AsyncIterable<unknown>) {
+        const messages = queue[Symbol.asyncIterator]();
+        await messages.next();
+        yield { Events: [wireEvent()], Partition: 'source', ReplayState: 0, InitialState: '' };
+        await messages.next();
+        await lifecycle.disconnected(error => { throw error; });
+        finish();
+    }
+    const connection = { reactors: { observe }, reducers: { observe }, readModels: { registerMany: async () => ({}) } } as unknown as ChronicleConnection;
+    const artifacts = {
+        eventTypes: [CanonicalMetadataRecorded], reactors: [CapturingReactor], reducers: [CapturingReducer],
+        readModels: [], seeders: [], constraints: [], projections: [], webhooks: [], eventTypeMigrations: []
+    } as IClientArtifactsProvider;
+    const runtime = kind === 'reactor'
+        ? new Reactors(artifacts, connection, 'store', 'tenant', lifecycle, {} as IEventLog)
+        : new Reducers(artifacts, connection, 'store', 'tenant', lifecycle, 'default-sink');
+    await runtime.register();
+    await finished;
+    if (!received) throw new Error(`No context delivered to ${kind}`);
+    return received;
+}
+
+for (const kind of ['read', 'reactor', 'reducer']) {
+    describe(`when receiving kernel metadata through a ${kind}`, () => {
+        let context: EventContext;
+        beforeEach(async () => { context = await receiveContext(kind); });
+        it('should retain the exact route and subject', () => {
+            [context.eventSourceType, context.eventSourceId, context.eventStreamType, context.eventStreamId, context.subject]
+                .should.deep.equal(['Source', 'source', 'Stream', 'stream-id', 'subject']);
+            context.eventStore!.should.equal('store');
+            context.namespace!.should.equal('tenant');
+        });
+        it('should retain timestamp, sequence number, event type, and canonical correlation id', () => {
+            context.occurred.toISOString().should.equal(occurred);
+            context.sequenceNumber.should.equal(9007199254740993n);
+            context.eventType.generation.value.should.equal(2);
+            context.eventType.tombstone.should.equal(true);
+            context.correlationId.should.equal(correlationId);
+        });
+        it('should retain tags, causation, identity, hash, and observation state', () => {
+            context.tags.map(tag => tag.value).should.deep.equal(['one', 'two']);
+            context.causation.should.deep.equal([{ type: 'command', occurred: new Date(occurred), properties: { key: 'value' } }]);
+            context.causedBy!.subject.should.equal('actor');
+            context.causedBy!.onBehalfOf!.subject.should.equal('delegate');
+            context.hash!.should.equal('persisted-hash');
+            context.observationState!.should.equal(1);
+        });
+    });
+}

package/events/toClientEventContext.ts

@@ -0,0 +1,45 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { fromContractsGuid } from '../connection/Guid';
+import { Identity } from '../identity/Identity';
+import type { EventContext } from './EventContext';
+import { EventType } from './EventType';
+import { EventTypeGeneration } from './EventTypeGeneration';
+import { EventTypeId } from './EventTypeId';
+import { Tag } from './Tag';
+import type { WireEventContext } from './WireEventContext';
+
+/** Converts kernel metadata identically for reads, reactors, and reducers. */
+export function toClientEventContext(context: WireEventContext): EventContext {
+    return {
+        eventStore: context.EventStore,
+        namespace: context.Namespace,
+        sequenceNumber: context.SequenceNumber,
+        eventSourceId: context.EventSourceId,
+        eventSourceType: context.EventSourceType,
+        eventStreamType: context.EventStreamType,
+        eventStreamId: context.EventStreamId,
+        subject: context.Subject,
+        hash: context.Hash,
+        observationState: context.ObservationState,
+        causedBy: toClientIdentity(context.CausedBy),
+        eventType: new EventType(
+            new EventTypeId(context.EventType?.Id ?? ''),
+            new EventTypeGeneration(context.EventType?.Generation ?? EventTypeGeneration.firstValue),
+            context.EventType?.Tombstone ?? false
+        ),
+        occurred: new Date(context.Occurred?.Value ?? ''),
+        correlationId: fromContractsGuid(context.CorrelationId).toString(),
+        causation: (context.Causation ?? []).map(causation => ({
+            type: causation.Type,
+            occurred: causation.Occurred ? new Date(causation.Occurred.Value) : undefined,
+            properties: { ...causation.Properties }
+        })),
+        tags: (context.Tags ?? []).map(value => new Tag(value))
+    };
+}
+
+function toClientIdentity(identity: WireEventContext['CausedBy']): Identity | undefined {
+    return identity ? new Identity(identity.Subject, identity.Name, identity.UserName, toClientIdentity(identity.OnBehalfOf)) : undefined;
+}

package/for_ChronicleClient/when_reconnecting/and_the_server_becomes_incompatible.spec.ts

@@ -0,0 +1,95 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { afterEach, beforeEach, chai, describe, it, vi } from 'vitest';
+import { ChronicleClient } from '../../ChronicleClient';
+import { ChronicleOptions } from '../../ChronicleOptions';
+import { IncompatibleChronicleServer } from '../../connection/IncompatibleChronicleServer';
+
+chai.should();
+
+const transport = vi.hoisted(() => ({
+    resetChannel: vi.fn(),
+    connect: vi.fn(),
+    disconnect: vi.fn(),
+    getVersionInfo: vi.fn(),
+    allEventStores: vi.fn(),
+    ensureEventStore: vi.fn(),
+    append: vi.fn(),
+    lost: undefined as ((reason: string, error: unknown) => void) | undefined
+}));
+
+vi.mock('../../connection/ChronicleConnection', () => ({
+    ChronicleConnection: class {
+        resetChannel = transport.resetChannel;
+        connect = transport.connect;
+        disconnect = transport.disconnect;
+        server = { getVersionInfo: transport.getVersionInfo };
+        eventStores = { allEventStores: transport.allEventStores, ensureEventStore: transport.ensureEventStore };
+        eventSequences = { append: transport.append };
+    }
+}));
+
+vi.mock('../../connection/KernelKeepAlive', () => ({
+    KernelKeepAlive: class {
+        constructor(_connections: unknown, onLost: (reason: string, error: unknown) => void) {
+            transport.lost = onLost;
+        }
+        async start() {}
+    }
+}));
+
+describe.each(['watchdog', 'keep-alive', 'awaited operation'])('when %s recovery reaches an incompatible server', boundary => {
+    let client: ChronicleClient;
+    let rejection: IncompatibleChronicleServer;
+
+    beforeEach(async () => {
+        vi.useFakeTimers();
+        vi.clearAllMocks();
+        transport.resetChannel.mockResolvedValue(undefined);
+        transport.connect.mockResolvedValue(undefined);
+        transport.getVersionInfo.mockResolvedValue({});
+        transport.allEventStores.mockResolvedValue({ IsAuthorized: true, Data: [] });
+        client = new ChronicleClient(ChronicleOptions.fromConnectionString('chronicle://localhost:35000', { discoveryPatterns: [] }));
+        await client.getEventStores();
+        rejection = new IncompatibleChronicleServer('The replacement server is incompatible.');
+    });
+
+    afterEach(() => {
+        client.dispose();
+        vi.useRealTimers();
+    });
+
+    it('should contain background rejection and fail current and later callers without retrying writes', async () => {
+        let rejectVerification!: (reason: unknown) => void;
+        const verification = new Promise<void>((_resolve, reject) => { rejectVerification = reject; });
+        transport.connect.mockReturnValue(verification);
+        let awaited: Promise<PromiseSettledResult<unknown>[]> | undefined;
+        if (boundary === 'watchdog') {
+            transport.getVersionInfo.mockRejectedValue(new Error('connection unavailable'));
+            await vi.advanceTimersByTimeAsync(5000);
+        } else if (boundary === 'keep-alive') {
+            transport.lost!('keep-alive-ended', new Error('connection unavailable'));
+            await vi.advanceTimersByTimeAsync(0);
+        } else {
+            transport.allEventStores.mockRejectedValueOnce(new Error('connection unavailable'));
+            awaited = Promise.allSettled([client.getEventStores()]);
+            await vi.advanceTimersByTimeAsync(0);
+        }
+        transport.connect.mock.calls.should.have.lengthOf(2);
+        const waiting = Promise.allSettled([client.getEventStores()]);
+        rejectVerification(rejection);
+        await vi.advanceTimersByTimeAsync(0);
+        const results = [...await waiting, ...(awaited ? await awaited : []), ...await Promise.allSettled([client.getEventStores()])];
+        results.forEach(result => {
+            result.status.should.equal('rejected');
+            if (result.status === 'rejected') result.reason.should.equal(rejection);
+        });
+        await vi.advanceTimersByTimeAsync(15000);
+        transport.connect.mock.calls.should.have.lengthOf(2);
+        transport.allEventStores.mock.calls.should.have.lengthOf(boundary === 'awaited operation' ? 2 : 1);
+        transport.ensureEventStore.mock.calls.should.have.lengthOf(0);
+        transport.append.mock.calls.should.have.lengthOf(0);
+        transport.disconnect.mock.calls.length.should.be.greaterThan(0);
+    });
+});

package/index.ts

@@ -25,6 +25,7 @@ import * as eventStoreSubscriptions from './eventStoreSubscriptions';
 import * as compliance from './compliance';
 
 export { ChronicleClient } from './ChronicleClient';
+export { IncompatibleChronicleServer } from './connection/IncompatibleChronicleServer';
 export type { IChronicleClient } from './IChronicleClient';
 export { ChronicleOptions } from './ChronicleOptions';
 export { EventStore } from './EventStore';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/chronicle",
-    "version": "5.1.0",
+    "version": "6.1.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",
@@ -160,7 +160,7 @@
     },
     "dependencies": {
         "@bufbuild/protobuf": "^2.15.0",
-        "@cratis/chronicle.contracts": "18.2.0",
+        "@cratis/chronicle.contracts": "18.5.0",
         "@grpc/grpc-js": "^1.14.4",
         "@opentelemetry/api": "^1.9.1",
         "nice-grpc": "^2.1.17",
@@ -172,9 +172,10 @@
         "@cratis/fundamentals": "7.19.2",
         "@types/node": "^26.5.1",
         "typescript": "^6.0.3",
-        "vitest": "^5.0.0"
+        "vite": "^8.3.0",
+        "vitest": "^5.0.1"
     },
     "peerDependencies": {
-        "@cratis/fundamentals": "^7.14.0"
+        "@cratis/fundamentals": "^7.19.2"
     }
 }

package/reactors/ReactorSideEffects.spec.ts

@@ -98,6 +98,8 @@ describe('appendReactorSideEffects', () => {
                 event: new SomethingHappened('a'),
                 eventStreamType: 'other-stream-type',
                 eventStreamId: 'other-stream-id',
+                eventSourceType: 'other-source-type',
+                occurred: new Date('2025-01-01T00:00:00Z'),
                 subject: 'other-subject'
             };
 

package/reactors/Reactors.ts

@@ -9,10 +9,7 @@ import { IClientArtifactsProvider } from '../artifacts';
 import { ChronicleConnection } from '../connection';
 import { ConnectionLifecycle } from '../connection/ConnectionLifecycle';
 import { getEventTypeMetadata } from '../events/eventTypeDecorator';
-import { EventContext } from '../events/EventContext';
-import { EventTypeId } from '../events/EventTypeId';
-import { EventTypeGeneration } from '../events/EventTypeGeneration';
-import { Tag } from '../events/Tag';
+import { toClientEventContext } from '../events/toClientEventContext';
 import { getTagsFor } from '../events/tagDecorator';
 import { getFilterTagsFor } from '../events/filterEventsByTagDecorator';
 import { EventSequenceId } from '../eventSequences/EventSequenceId';
@@ -296,19 +293,7 @@ export class Reactors implements IReactors {
 
                         const content = JSON.parse(event.Content) as Record<string, unknown>;
                         this._logger.debug('Event content', { reactorId: id, eventTypeId, contentKeys: Object.keys(content), rawContent: event.Content.substring(0, 200) });
-                        const context: EventContext = {
-                            sequenceNumber: event.Context!.SequenceNumber,
-                            eventSourceId: event.Context!.EventSourceId,
-                            eventType: {
-                                id: new EventTypeId(event.Context!.EventType!.Id),
-                                generation: new EventTypeGeneration(event.Context!.EventType!.Generation),
-                                tombstone: event.Context!.EventType!.Tombstone
-                            },
-                            occurred: new Date(event.Context!.Occurred?.Value ?? ''),
-                            correlationId: event.Context?.CorrelationId ? `${event.Context.CorrelationId.lo}-${event.Context.CorrelationId.hi}` : '',
-                            causation: [],
-                            tags: (event.Context!.Tags ?? []).map(value => new Tag(value))
-                        };
+                        const context = toClientEventContext(event.Context!);
 
                         this._logger.info('Invoking reactor handler', {
                             reactorId: id,

package/reducers/Reducers.ts

@@ -10,10 +10,7 @@ import { ChronicleConnection } from '../connection';
 import { toContractsGuid } from '../connection/Guid';
 import { ConnectionLifecycle } from '../connection/ConnectionLifecycle';
 import { getEventTypeMetadata } from '../events/eventTypeDecorator';
-import { EventContext } from '../events/EventContext';
-import { EventTypeId } from '../events/EventTypeId';
-import { EventTypeGeneration } from '../events/EventTypeGeneration';
-import { Tag } from '../events/Tag';
+import { toClientEventContext } from '../events/toClientEventContext';
 import { getTagsFor } from '../events/tagDecorator';
 import { getFilterTagsFor } from '../events/filterEventsByTagDecorator';
 import { EventSequenceId } from '../eventSequences/EventSequenceId';
@@ -315,6 +312,7 @@ export class Reducers implements IReducers {
                             Key: EVENT_SOURCE_ID_KEY
                         })),
                         ReadModel: readModelName,
+                        Hash: '',
                         IsActive: isActive,
                         Tags: getTagsFor(reducerType).map(t => t.value),
                         Filters: {
@@ -375,19 +373,7 @@ export class Reducers implements IReducers {
                         }
 
                         const content = JSON.parse(event.Content) as Record<string, unknown>;
-                        const context: EventContext = {
-                            sequenceNumber: event.Context!.SequenceNumber,
-                            eventSourceId: event.Context!.EventSourceId,
-                            eventType: {
-                                id: new EventTypeId(event.Context!.EventType!.Id),
-                                generation: new EventTypeGeneration(event.Context!.EventType!.Generation),
-                                tombstone: event.Context!.EventType!.Tombstone
-                            },
-                            occurred: new Date(event.Context!.Occurred?.Value ?? ''),
-                            correlationId: event.Context?.CorrelationId ? `${event.Context.CorrelationId.lo}-${event.Context.CorrelationId.hi}` : '',
-                            causation: [],
-                            tags: (event.Context!.Tags ?? []).map(value => new Tag(value))
-                        };
+                        const context = toClientEventContext(event.Context!);
 
                         this._logger.info('Invoking reducer handler', {
                             reducerId: id,

package/vitest.config.ts

@@ -5,7 +5,7 @@ import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
     test: {
-        include: ['**/*.spec.ts'],
+        include: ['**/*.spec.ts', '**/*.spec.js'],
         exclude: ['node_modules', 'dist'],
         environment: 'node'
     }