@cratis/chronicle 3.1.0 → 4.0.0

package/projections/modelBound/noAutoMap.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 'reflect-metadata';
+import { TypeIntrospector } from '../../types';
+
+const CLASS_METADATA_KEY = 'chronicle:projection:noAutoMap:class';
+const PROPERTY_METADATA_KEY = 'chronicle:projection:noAutoMap:property';
+
+/**
+ * Class or property decorator that disables AutoMap for a model-bound projection.
+ * Applied to a class, it prevents AutoMap from mapping any property automatically.
+ * Applied to a property, it excludes only that single property from AutoMap while every other
+ * property keeps mapping - use it to stop an unrelated event that carries an identically named
+ * property from silently overwriting a property whose value is set explicitly (for example via
+ * `setFrom`).
+ * @param target - The class constructor, or the class prototype when used on a property.
+ * @param propertyKey - The property name, when used as a property decorator.
+ */
+export function noAutoMap(target: object, propertyKey?: string | symbol): void {
+    if (propertyKey !== undefined) {
+        const key = propertyKey.toString();
+        TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, key);
+        Reflect.defineMetadata(PROPERTY_METADATA_KEY, true, target, key);
+    } else {
+        Reflect.defineMetadata(CLASS_METADATA_KEY, true, target as Function);
+    }
+}
+
+/**
+ * Checks whether the given class has AutoMap disabled entirely.
+ * @param target - The class constructor.
+ * @returns True if the class is marked with {@link noAutoMap}; false otherwise.
+ */
+export function isNoAutoMap(target: Function): boolean {
+    return Reflect.hasMetadata(CLASS_METADATA_KEY, target);
+}
+
+/**
+ * Checks whether a specific property is excluded from AutoMap.
+ * @param target - The class prototype.
+ * @param propertyKey - The property name.
+ * @returns True if the property is marked with {@link noAutoMap}; false otherwise.
+ */
+export function isPropertyNoAutoMap(target: object, propertyKey: string): boolean {
+    return Reflect.hasMetadata(PROPERTY_METADATA_KEY, target, propertyKey);
+}

package/reactors/Reactors.ts

@@ -12,6 +12,9 @@ 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 { getTagsFor } from '../events/tagDecorator';
+import { getFilterTagsFor } from '../events/filterEventsByTagDecorator';
 import { EventSequenceId } from '../eventSequences/EventSequenceId';
 import type { IEventLog } from '../eventSequences/IEventLog';
 import { notifyReplayLifecycle } from '../observation/notifyReplayLifecycle';
@@ -239,9 +242,9 @@ export class Reactors implements IReactors {
                             Key: EVENT_SOURCE_ID_KEY
                         })),
                         IsReplayable: false,
-                        Tags: [],
+                        Tags: getTagsFor(reactorType).map(t => t.value),
                         Filters: {
-                            FilterTags: [],
+                            FilterTags: getFilterTagsFor(reactorType).map(t => t.value),
                             EventSourceType: '',
                             EventStreamType: 'All'
                         }
@@ -303,7 +306,8 @@ export class Reactors implements IReactors {
                             },
                             occurred: new Date(event.Context!.Occurred?.Value ?? ''),
                             correlationId: event.Context?.CorrelationId ? `${event.Context.CorrelationId.lo}-${event.Context.CorrelationId.hi}` : '',
-                            causation: []
+                            causation: [],
+                            tags: (event.Context!.Tags ?? []).map(value => new Tag(value))
                         };
 
                         this._logger.info('Invoking reactor handler', {

package/readModels/MaterializedReadModels.spec.ts

@@ -0,0 +1,98 @@
+// 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 { describe, expect, it, vi } from 'vitest';
+import type { ChronicleConnection } from '../connection';
+import { pii } from '../compliance/pii';
+import { subject } from '../compliance/subject';
+import { readModel } from './readModel';
+import { MaterializedReadModels } from './MaterializedReadModels';
+
+// Decorators are applied as plain function calls (rather than `@decorator` syntax) so these
+// fixtures don't depend on the test runner's decorator-syntax support.
+
+function createMaterializedReadModels(instancesJson: string[], releaseResponse: Record<string, unknown> = { HasError: false, Payload: '{}' }) {
+    const release = vi.fn().mockResolvedValue(releaseResponse);
+    const getInstances = vi.fn().mockResolvedValue({ Instances: instancesJson });
+    const connection = {
+        compliance: { release },
+        materializedReadModels: { getInstances }
+    } as unknown as ChronicleConnection;
+
+    const readModels = new MaterializedReadModels('test-store', 'test-namespace', connection);
+    return { readModels, release };
+}
+
+describe('MaterializedReadModels', () => {
+    describe('when a read model has a property decorated with @subject()', () => {
+        class Employee {
+            id = '';
+            personId = '';
+            ssn = '';
+        }
+        field(String)(Employee.prototype, 'id');
+        field(String)(Employee.prototype, 'personId');
+        field(String)(Employee.prototype, 'ssn');
+        pii()(Employee.prototype, 'ssn');
+        subject()(Employee.prototype, 'personId');
+        readModel('EmployeeWithSubjectMaterialized')(Employee);
+
+        it('should release using the decorated property as the subject', async () => {
+            const json = JSON.stringify({ id: 'employee-1', personId: 'person-42', ssn: '123-45-6789' });
+            const { readModels, release } = createMaterializedReadModels([json]);
+
+            await readModels.getInstances(Employee);
+
+            expect(release).toHaveBeenCalledWith(expect.objectContaining({ Subject: 'person-42' }));
+        });
+    });
+
+    describe('when a read model has no property decorated with @subject() but has an id property', () => {
+        class Customer {
+            id = '';
+            ssn = '';
+        }
+        field(String)(Customer.prototype, 'id');
+        field(String)(Customer.prototype, 'ssn');
+        pii()(Customer.prototype, 'ssn');
+        readModel('CustomerWithIdOnlyMaterialized')(Customer);
+
+        it('should fall back to the id property as the subject, unchanged from today', async () => {
+            const json = JSON.stringify({ id: 'customer-7', ssn: '987-65-4321' });
+            const { readModels, release } = createMaterializedReadModels([json]);
+
+            await readModels.getInstances(Customer);
+
+            expect(release).toHaveBeenCalledWith(expect.objectContaining({ Subject: 'customer-7' }));
+        });
+    });
+
+    describe('when a read model has neither a decorated property nor an id property', () => {
+        class Anonymous {
+            ssn = '';
+        }
+        field(String)(Anonymous.prototype, 'ssn');
+        pii()(Anonymous.prototype, 'ssn');
+        readModel('AnonymousMaterialized')(Anonymous);
+
+        it('should not call release, unchanged from today', async () => {
+            const json = JSON.stringify({ ssn: '000-00-0000' });
+            const { readModels, release } = createMaterializedReadModels([json]);
+
+            await readModels.getInstances(Anonymous);
+
+            expect(release).not.toHaveBeenCalled();
+        });
+
+        it('should return the instance unreleased', async () => {
+            const json = JSON.stringify({ ssn: '000-00-0000' });
+            const { readModels } = createMaterializedReadModels([json]);
+
+            const [instance] = await readModels.getInstances(Anonymous);
+
+            expect(instance.ssn).toBe('000-00-0000');
+        });
+    });
+});

package/readModels/MaterializedReadModels.ts

@@ -6,6 +6,7 @@ import { JsonSerializer } from '@cratis/fundamentals';
 import { ChronicleConnection } from '../connection';
 import { JsonSchemaGenerator } from '../schemas';
 import { getReadModelMetadata } from './readModel';
+import { ReadModelSubjectResolver } from './ReadModelSubjectResolver';
 import type { IMaterializedReadModels } from './IMaterializedReadModels';
 
 const defaultTake = 50;
@@ -97,7 +98,7 @@ export class MaterializedReadModels implements IMaterializedReadModels {
     }
 
     private async releaseInstance<TReadModel>(readModelType: Constructor<TReadModel>, instance: TReadModel, schema: string): Promise<TReadModel> {
-        const subject = this.extractSubject(instance);
+        const subject = ReadModelSubjectResolver.resolveFrom(readModelType, instance);
         if (!subject) {
             return instance;
         }
@@ -141,11 +142,4 @@ export class MaterializedReadModels implements IMaterializedReadModels {
         }
     }
 
-    private extractSubject<TReadModel>(instance: TReadModel): string | undefined {
-        const anyInstance = instance as Record<string, unknown>;
-        if (anyInstance.id !== undefined && anyInstance.id !== null) {
-            return String(anyInstance.id);
-        }
-        return undefined;
-    }
 }

package/readModels/ReadModelSubjectResolver.spec.ts

@@ -0,0 +1,84 @@
+// 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 { describe, expect, it } from 'vitest';
+import { subject } from '../compliance/subject';
+import { ReadModelSubjectResolver } from './ReadModelSubjectResolver';
+
+// Decorators are applied as plain function calls (rather than `@decorator` syntax) so these
+// fixtures don't depend on the test runner's decorator-syntax support.
+
+describe('ReadModelSubjectResolver', () => {
+    describe('when the read model has a property decorated with @subject()', () => {
+        class Employee {
+            id = '';
+            personId = '';
+        }
+        subject()(Employee.prototype, 'personId');
+
+        it('should resolve to the decorated property value', () => {
+            const instance = new Employee();
+            instance.id = 'employee-1';
+            instance.personId = 'person-42';
+
+            expect(ReadModelSubjectResolver.resolveFrom(Employee, instance)).toBe('person-42');
+        });
+
+        it('should take precedence over the id property', () => {
+            const instance = new Employee();
+            instance.id = 'employee-1';
+            instance.personId = 'person-42';
+
+            expect(ReadModelSubjectResolver.resolveFrom(Employee, instance)).not.toBe('employee-1');
+        });
+
+        it('should fall back to id when the decorated property has no value', () => {
+            const instance = new Employee();
+            instance.id = 'employee-1';
+            instance.personId = '';
+
+            expect(ReadModelSubjectResolver.resolveFrom(Employee, instance)).toBe('employee-1');
+        });
+    });
+
+    describe('when the read model has no property decorated with @subject()', () => {
+        class Customer {
+            id = '';
+            name = '';
+        }
+
+        it('should fall back to the id property', () => {
+            const instance = new Customer();
+            instance.id = 'customer-7';
+
+            expect(ReadModelSubjectResolver.resolveFrom(Customer, instance)).toBe('customer-7');
+        });
+    });
+
+    describe('when the read model has neither a decorated property nor an id property', () => {
+        class Anonymous {
+            name = '';
+        }
+
+        it('should not resolve a subject', () => {
+            const instance = new Anonymous();
+
+            expect(ReadModelSubjectResolver.resolveFrom(Anonymous, instance)).toBeUndefined();
+        });
+    });
+
+    describe('when the instance does not exist', () => {
+        class Customer {
+            id = '';
+        }
+
+        it('should not resolve a subject for null', () => {
+            expect(ReadModelSubjectResolver.resolveFrom(Customer, null as unknown as Customer)).toBeUndefined();
+        });
+
+        it('should not resolve a subject for undefined', () => {
+            expect(ReadModelSubjectResolver.resolveFrom(Customer, undefined as unknown as Customer)).toBeUndefined();
+        });
+    });
+});

package/readModels/ReadModelSubjectResolver.ts

@@ -0,0 +1,44 @@
+// 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 { getSubjectPropertyName } from '../compliance/subject';
+
+/**
+ * Resolves the compliance subject - the natural person a read model's Personal Identifiable
+ * Information (PII) belongs to - from a read model instance.
+ */
+export class ReadModelSubjectResolver {
+    /**
+     * Attempts to derive the compliance subject from a read model instance.
+     *
+     * Resolution order:
+     * 1. The property decorated with `@subject()` on {@link readModelType}, when it has a value.
+     * 2. The `id` property, by convention - kept so read models that predate `@subject()`
+     *    continue to resolve exactly as before.
+     * @param readModelType - The read model type to resolve subject metadata for.
+     * @param instance - The read model instance to inspect, or undefined/null for a read model
+     * that does not exist.
+     * @returns The resolved subject, or undefined when neither source yields a value.
+     */
+    static resolveFrom<TReadModel>(readModelType: Constructor<TReadModel>, instance: TReadModel): string | undefined {
+        if (instance === undefined || instance === null) {
+            return undefined;
+        }
+
+        const anyInstance = instance as Record<string, unknown>;
+        const subjectProperty = getSubjectPropertyName(readModelType);
+        const explicitSubject = subjectProperty ? ReadModelSubjectResolver.toSubject(anyInstance[subjectProperty]) : undefined;
+
+        return explicitSubject ?? ReadModelSubjectResolver.toSubject(anyInstance.id);
+    }
+
+    private static toSubject(value: unknown): string | undefined {
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+
+        const stringValue = String(value);
+        return stringValue.length > 0 ? stringValue : undefined;
+    }
+}

package/readModels/ReadModels.spec.ts

@@ -0,0 +1,118 @@
+// 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 type { Constructor } from '@cratis/fundamentals';
+import { describe, expect, it, vi } from 'vitest';
+import type { IClientArtifactsProvider } from '../artifacts';
+import type { ChronicleConnection } from '../connection';
+import { subject } from '../compliance/subject';
+import { fromEvent } from '../projections/modelBound/fromEvent';
+import { readModel } from './readModel';
+import { ReadModels } from './ReadModels';
+
+// Decorators are applied as plain function calls (rather than `@decorator` syntax) so these
+// fixtures don't depend on the test runner's decorator-syntax support.
+
+class SomeEvent {
+    value = '';
+}
+
+function createReadModels(readModelType: Constructor, releaseResponse: Record<string, unknown> = { HasError: false, Payload: '{}' }) {
+    const release = vi.fn().mockResolvedValue(releaseResponse);
+    const connection = {
+        compliance: { release }
+    } as unknown as ChronicleConnection;
+
+    const clientArtifacts = {
+        eventTypes: [],
+        readModels: [readModelType],
+        reactors: [],
+        reducers: [],
+        seeders: [],
+        constraints: [],
+        projections: [],
+        webhooks: [],
+        eventTypeMigrations: []
+    } as IClientArtifactsProvider;
+
+    const readModels = new ReadModels('test-store', 'test-namespace', connection, clientArtifacts, 'default-sink');
+    return { readModels, release };
+}
+
+describe('ReadModels', () => {
+    describe('when releasing a read model with a property decorated with @subject()', () => {
+        class Employee {
+            id = '';
+            personId = '';
+        }
+        subject()(Employee.prototype, 'personId');
+        fromEvent(SomeEvent)(Employee);
+        readModel('EmployeeWithSubject')(Employee);
+
+        it('should release using the decorated property as the subject', async () => {
+            const { readModels, release } = createReadModels(Employee);
+            const instance = new Employee();
+            instance.id = 'employee-1';
+            instance.personId = 'person-42';
+
+            await readModels.release(Employee, instance);
+
+            expect(release).toHaveBeenCalledWith(expect.objectContaining({ Subject: 'person-42' }));
+        });
+    });
+
+    describe('when releasing a read model without @subject() but with an id property', () => {
+        class Customer {
+            id = '';
+        }
+        fromEvent(SomeEvent)(Customer);
+        readModel('CustomerWithIdOnly')(Customer);
+
+        it('should fall back to the id property as the subject, unchanged from today', async () => {
+            const { readModels, release } = createReadModels(Customer);
+            const instance = new Customer();
+            instance.id = 'customer-7';
+
+            await readModels.release(Customer, instance);
+
+            expect(release).toHaveBeenCalledWith(expect.objectContaining({ Subject: 'customer-7' }));
+        });
+    });
+
+    describe('when releasing a read model with neither @subject() nor an id property', () => {
+        class Anonymous {
+            name = '';
+        }
+        fromEvent(SomeEvent)(Anonymous);
+        readModel('AnonymousReadModel')(Anonymous);
+
+        it('should throw, same as today', async () => {
+            const { readModels } = createReadModels(Anonymous);
+            const instance = new Anonymous();
+
+            await expect(readModels.release(Anonymous, instance)).rejects.toThrow(/subject/);
+        });
+    });
+
+    describe('when releasing many read model instances', () => {
+        class Customer {
+            id = '';
+        }
+        fromEvent(SomeEvent)(Customer);
+        readModel('CustomerForReleaseMany')(Customer);
+
+        it('should release each instance using its own resolved subject', async () => {
+            const { readModels, release } = createReadModels(Customer);
+            const first = new Customer();
+            first.id = 'customer-1';
+            const second = new Customer();
+            second.id = 'customer-2';
+
+            await readModels.releaseMany(Customer, [first, second]);
+
+            expect(release).toHaveBeenCalledWith(expect.objectContaining({ Subject: 'customer-1' }));
+            expect(release).toHaveBeenCalledWith(expect.objectContaining({ Subject: 'customer-2' }));
+        });
+    });
+});

package/readModels/ReadModels.ts

@@ -23,6 +23,7 @@ import { WellKnownSinks } from '../sinks';
 import { getReadModelMetadata } from './readModel';
 import type { IMaterializedReadModels } from './IMaterializedReadModels';
 import { MaterializedReadModels } from './MaterializedReadModels';
+import { ReadModelSubjectResolver } from './ReadModelSubjectResolver';
 import type { IReadModels } from './IReadModels';
 import type { ReadModelChangeset } from './ReadModelChangeset';
 import type { ReadModelSnapshot } from './ReadModelSnapshot';
@@ -173,7 +174,7 @@ export class ReadModels implements IReadModels {
         const readModel = this.resolveReadModel(readModelType);
         const schema = this.getReadModelSchema(readModelType, readModel.identifier);
         const payload = JsonSerializer.serialize(instance);
-        const subject = this.extractSubject(instance);
+        const subject = this.extractSubject(readModelType, instance);
 
         const response = await this._connection.compliance.release({
             EventStore: this._eventStore,
@@ -345,12 +346,11 @@ export class ReadModels implements IReadModels {
         }
     }
 
-    private extractSubject<TReadModel>(instance: TReadModel): string {
-        // By convention, use the 'id' property as the subject
-        const anyInstance = instance as any;
-        if (anyInstance.id !== undefined && anyInstance.id !== null) {
-            return String(anyInstance.id);
+    private extractSubject<TReadModel>(readModelType: Constructor<TReadModel>, instance: TReadModel): string {
+        const subject = ReadModelSubjectResolver.resolveFrom(readModelType, instance);
+        if (subject !== undefined) {
+            return subject;
         }
-        throw new Error('Read model instance must have an "id" property to serve as the subject for PII release');
+        throw new Error('Read model instance must have a property decorated with @subject() or an "id" property to serve as the subject for PII release');
     }
 }

package/readModels/index.ts

@@ -6,6 +6,7 @@ export type { IReadModels } from './IReadModels';
 export type { IMaterializedReadModels } from './IMaterializedReadModels';
 export { ReadModels } from './ReadModels';
 export { MaterializedReadModels } from './MaterializedReadModels';
+export { ReadModelSubjectResolver } from './ReadModelSubjectResolver';
 export type { ReadModelChangeset } from './ReadModelChangeset';
 export type { ReadModelSnapshot } from './ReadModelSnapshot';
 export { readModel, getReadModelMetadata, isReadModel } from './readModel';

package/reducers/Reducers.spec.ts

@@ -6,11 +6,48 @@ import type { Constructor } from '@cratis/fundamentals';
 import type { IClientArtifactsProvider } from '../artifacts';
 import type { ChronicleConnection } from '../connection';
 import { ConnectionLifecycle } from '../connection/ConnectionLifecycle';
+import { eventType, getEventTypeFor } from '../events/eventTypeDecorator';
+import type { EventContext } from '../events/EventContext';
+import { filterEventsByTag } from '../events/filterEventsByTagDecorator';
+import { tag } from '../events/tagDecorator';
 import { reducer } from './reducer';
 import { Reducers } from './Reducers';
 
 const flush = () => new Promise(resolve => setTimeout(resolve, 0));
 
+class ReducersSomeEventHappened {
+    constructor(readonly value: string = '') {}
+}
+eventType('d2b2b2b2-2222-4a3c-9d3f-6f2f4a3c9d3f')(ReducersSomeEventHappened);
+
+class SomeTaggedReducerState {
+    count = 0;
+}
+
+class SomeTaggedReducer {
+    reducersSomeEventHappened(): SomeTaggedReducerState {
+        return { count: 1 };
+    }
+}
+reducer('some-tagged-reducer', undefined, SomeTaggedReducerState)(SomeTaggedReducer);
+tag('Analytics', 'Reporting')(SomeTaggedReducer);
+filterEventsByTag('vip')(SomeTaggedReducer);
+filterEventsByTag('priority')(SomeTaggedReducer);
+
+const receivedContexts: EventContext[] = [];
+
+class CapturingReducerState {
+    count = 0;
+}
+
+class CapturingReducer {
+    reducersSomeEventHappened(_event: ReducersSomeEventHappened, current: CapturingReducerState | undefined, context: EventContext): CapturingReducerState {
+        receivedContexts.push(context);
+        return { count: (current?.count ?? 0) + 1 };
+    }
+}
+reducer('capturing-reducer', undefined, CapturingReducerState)(CapturingReducer);
+
 /**
  * A minimal client artifacts provider exposing only the reducer types under test —
  * Reducers.ts only reads .reducers and .eventTypes off this during discovery.
@@ -84,4 +121,47 @@ describe('Reducers', () => {
             expect(message.Content.Value0.Reducer.IsActive).toBe(false);
         });
     });
+
+    describe('when registering a reducer that is tagged and filters by tag', () => {
+        type TaggedRegistration = {
+            Content: { Value0: { Reducer: { Tags: string[]; Filters: { FilterTags: string[] } } } };
+        };
+
+        const register = async () => {
+            const { connection, registrationMessages } = createConnection();
+            const reducers = new Reducers(createArtifacts([SomeTaggedReducer]), connection, 'my-event-store', 'my-namespace', new ConnectionLifecycle(), 'default-sink');
+
+            await reducers.register();
+            await flush();
+
+            return (registrationMessages[0] as TaggedRegistration).Content.Value0.Reducer;
+        };
+
+        it('should carry the tags the reducer is labeled with', async () => {
+            expect((await register()).Tags).toEqual(['Analytics', 'Reporting']);
+        });
+
+        it('should carry every tag it filters events by', async () => {
+            expect((await register()).Filters.FilterTags).toEqual(['vip', 'priority']);
+        });
+    });
+
+    describe('when registering a reducer that is neither tagged nor filtered', () => {
+        class SomeUntaggedReducer {}
+        reducer('some-untagged-reducer')(SomeUntaggedReducer);
+
+        it('should send empty tag lists rather than omitting them', async () => {
+            const { connection, registrationMessages } = createConnection();
+            const reducers = new Reducers(createArtifacts([SomeUntaggedReducer]), connection, 'my-event-store', 'my-namespace', new ConnectionLifecycle(), 'default-sink');
+
+            await reducers.register();
+            await flush();
+
+            const message = registrationMessages[0] as {
+                Content: { Value0: { Reducer: { Tags: string[]; Filters: { FilterTags: string[] } } } };
+            };
+            expect(message.Content.Value0.Reducer.Tags).toEqual([]);
+            expect(message.Content.Value0.Reducer.Filters.FilterTags).toEqual([]);
+        });
+    });
 });

package/reducers/Reducers.ts

@@ -10,6 +10,12 @@ 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 { getTagsFor } from '../events/tagDecorator';
+import { getFilterTagsFor } from '../events/filterEventsByTagDecorator';
 import { EventSequenceId } from '../eventSequences/EventSequenceId';
 import { notifyReplayLifecycle } from '../observation/notifyReplayLifecycle';
 import { IReducers } from './IReducers';
@@ -310,9 +316,9 @@ export class Reducers implements IReducers {
                         })),
                         ReadModel: readModelName,
                         IsActive: isActive,
-                        Tags: [],
+                        Tags: getTagsFor(reducerType).map(t => t.value),
                         Filters: {
-                            FilterTags: [],
+                            FilterTags: getFilterTagsFor(reducerType).map(t => t.value),
                             EventSourceType: '',
                             EventStreamType: 'All'
                         }
@@ -369,6 +375,19 @@ 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))
+                        };
 
                         this._logger.info('Invoking reducer handler', {
                             reducerId: id,
@@ -378,7 +397,7 @@ export class Reducers implements IReducers {
                             hasState: currentState !== undefined
                         });
 
-                        currentState = await reducerInstance[entry.methodName](content, currentState);
+                        currentState = await reducerInstance[entry.methodName](content, currentState, context);
                         lastSuccessfullyObservedEvent = event.Context!.SequenceNumber;
                     } catch (err) {
                         this._logger.error('Error handling event in reducer', { reducerId: id, error: String(err) });