@cratis/chronicle 6.27.0 → 6.29.0

package/projections/modelBound/childrenFrom.ts

@@ -20,8 +20,28 @@ export interface ChildrenFromMetadata {
     readonly parentKey?: string;
 }
 
+/** Options for the options form of the childrenFrom property decorator. */
+export interface ChildrenFromOptions {
+    /** The child type, for TypeScript runtimes without emitted generic metadata. */
+    readonly childType?: Function;
+    /** The event property name used as the key for children. Defaults to the event source identifier. */
+    readonly key?: string;
+    /** The child model property name used to uniquely identify instances in the collection. */
+    readonly identifiedBy?: string;
+    /** The event property name used as the parent key. Defaults to the event source identifier. */
+    readonly parentKey?: string;
+}
+
 const METADATA_KEY = 'chronicle:projection:childrenFrom';
 
+/**
+ * Property decorator that configures a children collection sub-projection from an event type.
+ * Use this form to name the child type and an explicit child key together.
+ * @param eventType - The event constructor.
+ * @param options - The child type, key, identifiedBy and parentKey.
+ * @returns A property decorator.
+ */
+export function childrenFrom(eventType: Function, options: ChildrenFromOptions): ChroniclePropertyDecorator;
 /**
  * Property decorator that configures a children collection sub-projection from an event type.
  * @param eventType - The event constructor.
@@ -30,24 +50,40 @@ const METADATA_KEY = 'chronicle:projection:childrenFrom';
  * @param parentKey - Optional event property name used as the parent key.
  * @returns A property decorator.
  */
+export function childrenFrom(eventType: Function, key?: string | Function, identifiedBy?: string, parentKey?: string): ChroniclePropertyDecorator;
 export function childrenFrom(
     eventType: Function,
-    key?: string | Function,
+    keyOrOptions?: string | Function | ChildrenFromOptions,
     identifiedBy?: string,
     parentKey?: string
 ): ChroniclePropertyDecorator {
+    const metadata = toMetadata(eventType, keyOrOptions, identifiedBy, parentKey);
     return decorateModelBoundProperty((target: object, propertyKey: string | symbol) => {
         const propKey = propertyKey.toString();
         TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, propKey);
         const existing: ChildrenFromMetadata[] = Reflect.getMetadata(METADATA_KEY, target, propKey) ?? [];
-        const metadata: ChildrenFromMetadata = {
-            eventType, key: typeof key === 'string' ? key : undefined,
-            childType: typeof key === 'function' ? key : undefined, identifiedBy, parentKey
-        };
         Reflect.defineMetadata(METADATA_KEY, [...existing, metadata], target, propKey);
     });
 }
 
+function toMetadata(
+    eventType: Function,
+    keyOrOptions: string | Function | ChildrenFromOptions | undefined,
+    identifiedBy: string | undefined,
+    parentKey: string | undefined
+): ChildrenFromMetadata {
+    if (typeof keyOrOptions === 'object' && keyOrOptions !== null) {
+        return {
+            eventType, childType: keyOrOptions.childType, key: keyOrOptions.key,
+            identifiedBy: keyOrOptions.identifiedBy, parentKey: keyOrOptions.parentKey
+        };
+    }
+    return {
+        eventType, key: typeof keyOrOptions === 'string' ? keyOrOptions : undefined,
+        childType: typeof keyOrOptions === 'function' ? keyOrOptions : undefined, identifiedBy, parentKey
+    };
+}
+
 /**
  * Retrieves all childrenFrom metadata stored on the given property.
  * @param target - The class prototype.

package/projections/modelBound/index.ts

@@ -21,7 +21,7 @@ export type { DecrementMetadata } from './decrement.js';
 export { count, getCountMetadata } from './count.js';
 export type { CountMetadata } from './count.js';
 export { childrenFrom, getChildrenFromMetadata } from './childrenFrom.js';
-export type { ChildrenFromMetadata } from './childrenFrom.js';
+export type { ChildrenFromMetadata, ChildrenFromOptions } from './childrenFrom.js';
 export { nested, isNested } from './nested.js';
 export { clearWith, getClearWithClassMetadata, getClearWithPropertyMetadata } from './clearWith.js';
 export type { ClearWithMetadata } from './clearWith.js';

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';