@cratis/chronicle 6.28.0 → 6.29.0

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
             });
         });