@cratis/chronicle 6.28.0 → 6.30.0

package/projections/Projections.ts

@@ -12,6 +12,7 @@ import { JobId } from '../jobs/JobId.js';
 import { FailedPartition } from '../observation/FailedPartition.js';
 import { FailedPartitions } from '../observation/FailedPartitions.js';
 import { toObserverRunningState } from '../observation/toObserverRunningState.js';
+import type { ReadModelNamingPolicy } from '../readModels/ReadModelNamingPolicy.js';
 import { getReadModelId } from '../readModels/readModel.js';
 import { assertUniqueReadModelIds } from '../readModels/assertUniqueReadModelIds.js';
 import { rootReadModelTypes } from '../readModels/rootReadModelTypes.js';
@@ -44,13 +45,15 @@ export class Projections implements IProjections {
      * @param _connection - Chronicle connection.
      * @param _clientArtifacts - Provider for discovered client artifact types.
      * @param _defaultSinkTypeId - The identifier of the default read model sink.
+     * @param _readModelNamingPolicy - Optional policy naming the container of each read model.
      */
     constructor(
         private readonly _eventStore: string,
         private readonly _namespace: string,
         private readonly _connection: ChronicleConnection,
         private readonly _clientArtifacts: IClientArtifactsProvider,
-        private readonly _defaultSinkTypeId: string
+        private readonly _defaultSinkTypeId: string,
+        private readonly _readModelNamingPolicy?: ReadModelNamingPolicy
     ) {
         this._failedPartitions = new FailedPartitions(_eventStore, _namespace, _connection);
     }
@@ -104,7 +107,7 @@ export class Projections implements IProjections {
             .map(type => getProjectionMetadata(type)?.readModelType)
             .filter((type): type is Constructor => type !== undefined);
         assertUniqueReadModelIds([...rootReadModelTypes(this._clientArtifacts), ...inferred]);
-        const compiled = new ProjectionDefinitionCompiler(this._clientArtifacts, this._defaultSinkTypeId)
+        const compiled = new ProjectionDefinitionCompiler(this._clientArtifacts, this._defaultSinkTypeId, this._readModelNamingPolicy)
             .compile(this._declarative.values(), this._modelBound.values());
         const projections = compiled.definitions;
 

package/readModels/ReadModelNamingPolicy.ts

@@ -0,0 +1,16 @@
+// 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';
+
+/**
+ * Decides the container name a read model is stored under: the collection, table, or file the sink writes to.
+ * The identifier the read model is registered and queried by is not affected.
+ *
+ * When no policy is configured the container name is the read model identifier.
+ * @param identifier - The read model identifier.
+ * @param readModelType - The read model class, when the client knows it. A projection whose read model is only
+ * named by identifier has no class, so this is undefined.
+ * @returns The container name to register the read model with.
+ */
+export type ReadModelNamingPolicy = (identifier: string, readModelType?: Constructor) => string;

package/readModels/ReadModels.ts

@@ -29,6 +29,7 @@ import type { IMaterializedReadModels } from './IMaterializedReadModels.js';
 import { MaterializedReadModels } from './MaterializedReadModels.js';
 import { ReadModelSubjectResolver } from './ReadModelSubjectResolver.js';
 import { deserializeReadModel } from './deserializeReadModel.js';
+import type { ReadModelNamingPolicy } from './ReadModelNamingPolicy.js';
 import type { IReadModels } from './IReadModels.js';
 import type { ReadModelChangeset } from './ReadModelChangeset.js';
 import type { ReadModelSnapshot } from './ReadModelSnapshot.js';
@@ -58,7 +59,8 @@ export class ReadModels implements IReadModels {
         private readonly _connection: ChronicleConnection,
         private readonly _clientArtifacts: IClientArtifactsProvider,
         private readonly _defaultSinkTypeId: string,
-        private readonly _isModelBoundProjectionRegistered?: (readModelType: Constructor) => boolean
+        private readonly _isModelBoundProjectionRegistered?: (readModelType: Constructor) => boolean,
+        private readonly _readModelNamingPolicy?: ReadModelNamingPolicy
     ) {
         this.materialized = new MaterializedReadModels(_eventStore, _namespace, _connection);
     }
@@ -349,7 +351,8 @@ export class ReadModels implements IReadModels {
             // None sink and the kernel resolves them via immediate projection instead of an empty sink.
             sinkTypeId: readModel.isActive ? this._defaultSinkTypeId : WellKnownSinks.None,
             observerType: readModel.observerType,
-            observerIdentifier: readModel.observerIdentifier
+            observerIdentifier: readModel.observerIdentifier,
+            namingPolicy: this._readModelNamingPolicy
         });
     }
 

package/readModels/buildReadModelDefinition.ts

@@ -2,9 +2,10 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { ReadModelObserverType } from '@cratis/chronicle.contracts';
-import { Guid } from '@cratis/fundamentals';
+import { Constructor, Guid } from '@cratis/fundamentals';
 import { toContractsGuid } from '../connection/Guid.js';
 import { getIndexesForType } from './indexDecorator.js';
+import type { ReadModelNamingPolicy } from './ReadModelNamingPolicy.js';
 
 interface ReadModelDefinitionOptions {
     identifier: string;
@@ -13,6 +14,8 @@ interface ReadModelDefinitionOptions {
     sinkTypeId: string;
     observerType: ReadModelObserverType;
     observerIdentifier: string;
+    /** Chooses the container name. Absent means the container is named by the identifier. */
+    namingPolicy?: ReadModelNamingPolicy;
 }
 
 /** Builds the registration payload shared by projections, reducers, and direct read-model registration. */
@@ -22,7 +25,7 @@ export function buildReadModelDefinition(options: ReadModelDefinitionOptions) {
             Identifier: options.identifier,
             Generation: 1
         },
-        ContainerName: options.identifier,
+        ContainerName: options.namingPolicy ? options.namingPolicy(options.identifier, options.type as Constructor | undefined) : options.identifier,
         DisplayName: options.identifier,
         Sink: {
             ConfigurationId: toContractsGuid(Guid.empty),

package/readModels/for_ReadModelNamingPolicy/given/registered_read_models.ts

@@ -0,0 +1,137 @@
+// 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 { Constructor } from '@cratis/fundamentals';
+import { vi } from 'vitest';
+import type { IClientArtifactsProvider } from '../../../artifacts/index.js';
+import type { ChronicleConnection } from '../../../connection/index.js';
+import { ConnectionLifecycle } from '../../../connection/ConnectionLifecycle.js';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import { IProjectionBuilderFor } from '../../../projections/declarative/IProjectionBuilderFor.js';
+import { IProjectionFor } from '../../../projections/declarative/IProjectionFor.js';
+import { projection } from '../../../projections/declarative/projection.js';
+import { fromEvent } from '../../../projections/modelBound/fromEvent.js';
+import { setFrom } from '../../../projections/modelBound/setFrom.js';
+import { Projections } from '../../../projections/Projections.js';
+import { reducer } from '../../../reducers/reducer.js';
+import { Reducers } from '../../../reducers/Reducers.js';
+import { ReadModels } from '../../ReadModels.js';
+import type { ReadModelNamingPolicy } from '../../ReadModelNamingPolicy.js';
+
+export class AccountOpened { owner!: string; }
+eventType()(AccountOpened);
+
+export class AccountSummary { id!: string; owner!: string; }
+export class AccountSummaryProjection implements IProjectionFor<AccountSummary> {
+    define(builder: IProjectionBuilderFor<AccountSummary>): void {
+        builder.from(AccountOpened);
+    }
+}
+projection('AccountSummary', AccountSummary)(AccountSummaryProjection);
+
+export class AccountBalance { id!: string; owner!: string; }
+setFrom(AccountOpened, 'owner')(AccountBalance.prototype, 'owner');
+fromEvent(AccountOpened)(AccountBalance);
+
+export class AccountActivity { count = 0; }
+export class AccountActivityReducer {
+    accountOpened(_event: AccountOpened, current: AccountActivity | undefined): AccountActivity {
+        return { count: (current?.count ?? 0) + 1 };
+    }
+}
+reducer('account-activity', undefined, AccountActivity)(AccountActivityReducer);
+
+/** Container name a policy that upper-cases the identifier and reports the class it was given. */
+export const upperCasePolicy: ReadModelNamingPolicy = identifier => identifier.toUpperCase();
+
+/** Identifies the class handed to the policy, or `none` when the read model has no class. */
+export const classNamePolicy: ReadModelNamingPolicy = (identifier, readModelType) => `${identifier}:${readModelType?.name ?? 'none'}`;
+
+export interface RegisteredReadModel {
+    identifier: string;
+    containerName: string;
+    displayName: string;
+}
+
+function artifacts(overrides: Partial<IClientArtifactsProvider>): IClientArtifactsProvider {
+    return {
+        eventTypes: [AccountOpened],
+        readModels: [],
+        reactors: [],
+        reducers: [],
+        seeders: [],
+        constraints: [],
+        projections: [],
+        webhooks: [],
+        eventTypeMigrations: [],
+        globalForHandlers: [],
+        ...overrides
+    };
+}
+
+interface Definition {
+    Type: { Identifier: string };
+    ContainerName: string;
+    DisplayName: string;
+}
+
+function toRegistered(registerMany: ReturnType<typeof vi.fn>): RegisteredReadModel[] {
+    return registerMany.mock.calls.flatMap(call => (call[0].ReadModels as Definition[]).map(definition => ({
+        identifier: definition.Type.Identifier,
+        containerName: definition.ContainerName,
+        displayName: definition.DisplayName
+    })));
+}
+
+/** Registers a declarative projection through {@link Projections} and returns what reached the kernel. */
+export async function registerDeclarativeProjection(policy?: ReadModelNamingPolicy): Promise<RegisteredReadModel[]> {
+    const registerMany = vi.fn().mockResolvedValue(undefined);
+    const connection = { projections: { register: vi.fn().mockResolvedValue(undefined) }, readModels: { registerMany } } as unknown as ChronicleConnection;
+    const provider = artifacts({ projections: [AccountSummaryProjection], readModels: [AccountSummary] });
+    await new Projections('store', 'Default', connection, provider, 'sink', policy).register();
+    return toRegistered(registerMany);
+}
+
+/** Registers a model-bound projection through {@link Projections} and returns what reached the kernel. */
+export async function registerModelBoundProjection(policy?: ReadModelNamingPolicy): Promise<RegisteredReadModel[]> {
+    const registerMany = vi.fn().mockResolvedValue(undefined);
+    const connection = { projections: { register: vi.fn().mockResolvedValue(undefined) }, readModels: { registerMany } } as unknown as ChronicleConnection;
+    const provider = artifacts({ readModels: [AccountBalance] });
+    await new Projections('store', 'Default', connection, provider, 'sink', policy).register();
+    return toRegistered(registerMany);
+}
+
+/** Registers a reducer's read model through {@link Reducers} and returns what reached the kernel. */
+export async function registerReducer(policy?: ReadModelNamingPolicy): Promise<RegisteredReadModel[]> {
+    const registerMany = vi.fn().mockResolvedValue({});
+    const observe = vi.fn().mockImplementation(async function* (queue: AsyncIterable<unknown>) {
+        for await (const _message of queue) break;
+    });
+    const connection = { reducers: { observe }, readModels: { registerMany } } as unknown as ChronicleConnection;
+    const provider = artifacts({ reducers: [AccountActivityReducer], readModels: [AccountActivity] });
+    const lifecycle = new ConnectionLifecycle();
+    const reducers = new Reducers(provider, connection, 'store', 'Default', lifecycle, 'sink', undefined, undefined, policy);
+    try {
+        await reducers.register();
+    } finally {
+        reducers.dispose();
+    }
+    return toRegistered(registerMany);
+}
+
+/** Registers read models directly through {@link ReadModels.register} and returns what reached the kernel. */
+export async function registerDirectly(readModelType: Constructor, artifactOverrides: Partial<IClientArtifactsProvider>, policy?: ReadModelNamingPolicy): Promise<RegisteredReadModel[]> {
+    const registerMany = vi.fn().mockResolvedValue(undefined);
+    const connection = { readModels: { registerMany } } as unknown as ChronicleConnection;
+    const readModels = new ReadModels('store', 'Default', connection, artifacts(artifactOverrides), 'sink', undefined, policy);
+    await readModels.register(readModelType);
+    return toRegistered(registerMany);
+}
+
+export const directProjection = (policy?: ReadModelNamingPolicy) =>
+    registerDirectly(AccountSummary, { projections: [AccountSummaryProjection], readModels: [AccountSummary] }, policy);
+export const directModelBound = (policy?: ReadModelNamingPolicy) =>
+    registerDirectly(AccountBalance, { readModels: [AccountBalance] }, policy);
+export const directReducer = (policy?: ReadModelNamingPolicy) =>
+    registerDirectly(AccountActivity, { reducers: [AccountActivityReducer], readModels: [AccountActivity] }, policy);

package/readModels/for_ReadModelNamingPolicy/when_configuring_options/with_a_naming_policy.spec.ts

@@ -0,0 +1,96 @@
+// 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 { ChronicleClient } from '../../../ChronicleClient.js';
+import { ChronicleOptions } from '../../../ChronicleOptions.js';
+import { EventStore } from '../../../EventStore.js';
+import type { IClientArtifactsProvider } from '../../../artifacts/index.js';
+import { AccountBalance, AccountOpened, upperCasePolicy } from '../given/registered_read_models.js';
+
+chai.should();
+
+const transport = vi.hoisted(() => ({
+    connect: vi.fn(),
+    getVersionInfo: vi.fn(),
+    ensureEventStore: vi.fn(),
+    registerMany: vi.fn()
+}));
+
+vi.mock('../../../connection/ChronicleConnection', () => ({
+    ChronicleConnection: class {
+        resetChannel = vi.fn().mockResolvedValue(undefined);
+        connect = transport.connect;
+        disconnect = vi.fn();
+        server = { getVersionInfo: transport.getVersionInfo };
+        eventStores = { ensureEventStore: transport.ensureEventStore };
+        readModels = { registerMany: transport.registerMany };
+    }
+}));
+
+vi.mock('../../../connection/KernelKeepAlive', () => ({
+    KernelKeepAlive: class {
+        async start() {}
+    }
+}));
+
+const artifacts: IClientArtifactsProvider = {
+    eventTypes: [AccountOpened],
+    readModels: [AccountBalance],
+    reactors: [],
+    reducers: [],
+    seeders: [],
+    constraints: [],
+    projections: [],
+    webhooks: [],
+    eventTypeMigrations: [],
+    globalForHandlers: []
+};
+
+const connectionString = 'chronicle://localhost:35000';
+
+describe('when configuring options without a read model naming policy', () => {
+    it('should not carry a naming policy', () => {
+        (ChronicleOptions.fromConnectionString(connectionString).readModelNamingPolicy === undefined).should.be.true;
+    });
+});
+
+describe('when configuring options with a read model naming policy', () => {
+    it('should carry the policy from the connection string factory', () => {
+        ChronicleOptions.fromConnectionString(connectionString, { readModelNamingPolicy: upperCasePolicy })
+            .readModelNamingPolicy!.should.equal(upperCasePolicy);
+    });
+
+    it('should carry the policy from the development factory', () => {
+        ChronicleOptions.development({ readModelNamingPolicy: upperCasePolicy })
+            .readModelNamingPolicy!.should.equal(upperCasePolicy);
+    });
+});
+
+describe('when an event store registers read models for a client configured with a naming policy', () => {
+    let containerName: string;
+
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        // Registration of every artifact kind is covered elsewhere; only the store's read-model wiring matters here.
+        vi.spyOn(EventStore.prototype, 'registerArtifacts').mockResolvedValue(undefined);
+        transport.connect.mockResolvedValue(undefined);
+        transport.getVersionInfo.mockResolvedValue({});
+        transport.ensureEventStore.mockResolvedValue({ IsSuccess: true });
+        transport.registerMany.mockResolvedValue(undefined);
+        const client = new ChronicleClient(ChronicleOptions.fromConnectionString(connectionString, {
+            discoveryPatterns: [],
+            clientArtifactsProvider: artifacts,
+            readModelNamingPolicy: upperCasePolicy
+        }));
+        try {
+            const store = await client.getEventStore('store');
+            await store.readModels.register(AccountBalance);
+            containerName = transport.registerMany.mock.calls[0][0].ReadModels[0].ContainerName;
+        } finally {
+            client.dispose();
+        }
+    });
+
+    it('should name the container with the policy result', () => containerName.should.equal('ACCOUNTBALANCE'));
+});

package/readModels/for_ReadModelNamingPolicy/when_registering/a_declarative_projection.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 { beforeEach, chai, describe, it } from 'vitest';
+import { classNamePolicy, registerDeclarativeProjection, upperCasePolicy, type RegisteredReadModel } from '../given/registered_read_models.js';
+
+chai.should();
+
+describe('when registering a declarative projection without a naming policy', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await registerDeclarativeProjection();
+    });
+
+    it('should keep the identifier', () => registered.identifier.should.equal('AccountSummary'));
+    it('should name the container by the identifier', () => registered.containerName.should.equal('AccountSummary'));
+});
+
+describe('when registering a declarative projection with a naming policy', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await registerDeclarativeProjection(upperCasePolicy);
+    });
+
+    it('should keep the identifier', () => registered.identifier.should.equal('AccountSummary'));
+    it('should keep the display name', () => registered.displayName.should.equal('AccountSummary'));
+    it('should name the container with the policy result', () => registered.containerName.should.equal('ACCOUNTSUMMARY'));
+});
+
+describe('when registering a declarative projection with a naming policy that uses the class', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await registerDeclarativeProjection(classNamePolicy);
+    });
+
+    it('should hand the read model class to the policy', () => registered.containerName.should.equal('AccountSummary:AccountSummary'));
+});

package/readModels/for_ReadModelNamingPolicy/when_registering/a_model_bound_projection.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 { beforeEach, chai, describe, it } from 'vitest';
+import { classNamePolicy, registerModelBoundProjection, upperCasePolicy, type RegisteredReadModel } from '../given/registered_read_models.js';
+
+chai.should();
+
+describe('when registering a model-bound projection without a naming policy', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await registerModelBoundProjection();
+    });
+
+    it('should keep the identifier', () => registered.identifier.should.equal('AccountBalance'));
+    it('should name the container by the identifier', () => registered.containerName.should.equal('AccountBalance'));
+});
+
+describe('when registering a model-bound projection with a naming policy', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await registerModelBoundProjection(upperCasePolicy);
+    });
+
+    it('should keep the identifier', () => registered.identifier.should.equal('AccountBalance'));
+    it('should keep the display name', () => registered.displayName.should.equal('AccountBalance'));
+    it('should name the container with the policy result', () => registered.containerName.should.equal('ACCOUNTBALANCE'));
+});
+
+describe('when registering a model-bound projection with a naming policy that uses the class', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await registerModelBoundProjection(classNamePolicy);
+    });
+
+    it('should hand the read model class to the policy', () => registered.containerName.should.equal('AccountBalance:AccountBalance'));
+});

package/readModels/for_ReadModelNamingPolicy/when_registering/a_model_bound_read_model_directly.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 { beforeEach, chai, describe, it } from 'vitest';
+import { classNamePolicy, directModelBound, upperCasePolicy, type RegisteredReadModel } from '../given/registered_read_models.js';
+
+chai.should();
+
+describe('when registering a model-bound read model directly without a naming policy', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await directModelBound();
+    });
+
+    it('should keep the identifier', () => registered.identifier.should.equal('AccountBalance'));
+    it('should name the container by the identifier', () => registered.containerName.should.equal('AccountBalance'));
+});
+
+describe('when registering a model-bound read model directly with a naming policy', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await directModelBound(upperCasePolicy);
+    });
+
+    it('should keep the identifier', () => registered.identifier.should.equal('AccountBalance'));
+    it('should keep the display name', () => registered.displayName.should.equal('AccountBalance'));
+    it('should name the container with the policy result', () => registered.containerName.should.equal('ACCOUNTBALANCE'));
+});
+
+describe('when registering a model-bound read model directly with a naming policy that uses the class', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await directModelBound(classNamePolicy);
+    });
+
+    it('should hand the read model class to the policy', () => registered.containerName.should.equal('AccountBalance:AccountBalance'));
+});

package/readModels/for_ReadModelNamingPolicy/when_registering/a_projection_directly.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 { beforeEach, chai, describe, it } from 'vitest';
+import { classNamePolicy, directProjection, upperCasePolicy, type RegisteredReadModel } from '../given/registered_read_models.js';
+
+chai.should();
+
+describe('when registering a projection read model directly without a naming policy', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await directProjection();
+    });
+
+    it('should keep the identifier', () => registered.identifier.should.equal('AccountSummary'));
+    it('should name the container by the identifier', () => registered.containerName.should.equal('AccountSummary'));
+});
+
+describe('when registering a projection read model directly with a naming policy', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await directProjection(upperCasePolicy);
+    });
+
+    it('should keep the identifier', () => registered.identifier.should.equal('AccountSummary'));
+    it('should keep the display name', () => registered.displayName.should.equal('AccountSummary'));
+    it('should name the container with the policy result', () => registered.containerName.should.equal('ACCOUNTSUMMARY'));
+});
+
+describe('when registering a projection read model directly with a naming policy that uses the class', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await directProjection(classNamePolicy);
+    });
+
+    it('should hand the read model class to the policy', () => registered.containerName.should.equal('AccountSummary:AccountSummary'));
+});

package/readModels/for_ReadModelNamingPolicy/when_registering/a_reducer.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 { beforeEach, chai, describe, it } from 'vitest';
+import { classNamePolicy, registerReducer, upperCasePolicy, type RegisteredReadModel } from '../given/registered_read_models.js';
+
+chai.should();
+
+describe('when registering a reducer without a naming policy', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await registerReducer();
+    });
+
+    it('should keep the identifier', () => registered.identifier.should.equal('AccountActivity'));
+    it('should name the container by the identifier', () => registered.containerName.should.equal('AccountActivity'));
+});
+
+describe('when registering a reducer with a naming policy', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await registerReducer(upperCasePolicy);
+    });
+
+    it('should keep the identifier', () => registered.identifier.should.equal('AccountActivity'));
+    it('should keep the display name', () => registered.displayName.should.equal('AccountActivity'));
+    it('should name the container with the policy result', () => registered.containerName.should.equal('ACCOUNTACTIVITY'));
+});
+
+describe('when registering a reducer with a naming policy that uses the class', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await registerReducer(classNamePolicy);
+    });
+
+    it('should hand the read model class to the policy', () => registered.containerName.should.equal('AccountActivity:AccountActivity'));
+});

package/readModels/for_ReadModelNamingPolicy/when_registering/a_reducer_read_model_directly.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 { beforeEach, chai, describe, it } from 'vitest';
+import { classNamePolicy, directReducer, upperCasePolicy, type RegisteredReadModel } from '../given/registered_read_models.js';
+
+chai.should();
+
+describe('when registering a reducer read model directly without a naming policy', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await directReducer();
+    });
+
+    it('should keep the identifier', () => registered.identifier.should.equal('AccountActivity'));
+    it('should name the container by the identifier', () => registered.containerName.should.equal('AccountActivity'));
+});
+
+describe('when registering a reducer read model directly with a naming policy', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await directReducer(upperCasePolicy);
+    });
+
+    it('should keep the identifier', () => registered.identifier.should.equal('AccountActivity'));
+    it('should keep the display name', () => registered.displayName.should.equal('AccountActivity'));
+    it('should name the container with the policy result', () => registered.containerName.should.equal('ACCOUNTACTIVITY'));
+});
+
+describe('when registering a reducer read model directly with a naming policy that uses the class', () => {
+    let registered: RegisteredReadModel;
+
+    beforeEach(async () => {
+        [registered] = await directReducer(classNamePolicy);
+    });
+
+    it('should hand the read model class to the policy', () => registered.containerName.should.equal('AccountActivity:AccountActivity'));
+});

package/readModels/index.ts

@@ -10,5 +10,6 @@ export { MaterializedReadModels } from './MaterializedReadModels.js';
 export { ReadModelSubjectResolver } from './ReadModelSubjectResolver.js';
 export type { ReadModelChangeset } from './ReadModelChangeset.js';
 export type { ReadModelSnapshot } from './ReadModelSnapshot.js';
+export type { ReadModelNamingPolicy } from './ReadModelNamingPolicy.js';
 export { readModel, getReadModelMetadata, isReadModel } from './readModel.js';
 export type { ReadModelMetadata } from './readModel.js';

package/reducers/Reducers.ts

@@ -19,6 +19,7 @@ import { ReducerEventDispatcher } from './ReducerEventDispatcher.js';
 import { getReadModelMetadata } from '../readModels/index.js';
 import { getReadModelId } from '../readModels/readModel.js';
 import { buildReadModelDefinition } from '../readModels/buildReadModelDefinition.js';
+import type { ReadModelNamingPolicy } from '../readModels/ReadModelNamingPolicy.js';
 import { assertUniqueReadModelIds } from '../readModels/assertUniqueReadModelIds.js';
 import { JsonSchemaGenerator } from '../schemas/index.js';
 import type { IEventStore } from '../IEventStore.js';
@@ -117,6 +118,9 @@ export class Reducers implements IReducers {
      * @param _namespace - The namespace within the event store.
      * @param lifecycle - The connection lifecycle used to react to disconnect events.
      * @param _defaultSinkTypeId - The default sink type identifier used when registering read models.
+     * @param _eventStore - The event store handed to reducers that request it.
+     * @param _artifactActivator - Optional per-delivery activator.
+     * @param _readModelNamingPolicy - Optional policy naming the container of each read model.
      */
     constructor(
         private readonly _clientArtifacts: IClientArtifactsProvider,
@@ -126,7 +130,8 @@ export class Reducers implements IReducers {
         lifecycle: ConnectionLifecycle,
         private readonly _defaultSinkTypeId: string,
         private readonly _eventStore?: IEventStore,
-        private readonly _artifactActivator?: ClientArtifactsActivator
+        private readonly _artifactActivator?: ClientArtifactsActivator,
+        private readonly _readModelNamingPolicy?: ReadModelNamingPolicy
     ) {
         this._lifecycle = lifecycle;
         lifecycle.onDisconnected(async () => {
@@ -190,7 +195,8 @@ export class Reducers implements IReducers {
                 schema: this.getReducerSchema(reducerType, readModelName),
                 sinkTypeId: this._defaultSinkTypeId,
                 observerType: ReadModelObserverType.Reducer,
-                observerIdentifier: id
+                observerIdentifier: id,
+                namingPolicy: this._readModelNamingPolicy
             });
         });
 

package/testing/ReactorScenario.ts

@@ -140,6 +140,8 @@ export class ReactorScenario {
     get produced(): readonly unknown[] { return Object.freeze(this._effects.map(effect => effect.value)); }
     get sideEffects(): readonly RecordedReactorSideEffect[] { return Object.freeze([...this._effects]); }
     get results(): readonly ReactorDeliveryResult[] { return Object.freeze([...this._results]); }
+    /** Committed input and explicit service appends; recorded returned effects are not part of this history. */
+    get appendedEvents(): readonly AppendedEvent[] { return this._events.appendedEvents; }
     /** Assertion view, deliberately not a callable Promise-like `then`. */
     get then(): { readonly produced: readonly unknown[]; readonly sideEffects: readonly RecordedReactorSideEffect[];
         readonly results: readonly ReactorDeliveryResult[] } {