@cratis/chronicle 6.11.0 → 6.12.0

package/readModels/indexRegistration.spec.ts

@@ -0,0 +1,99 @@
+// 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 { 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 { Projections } from '../projections/Projections.js';
+import { projection } from '../projections/declarative/projection.js';
+import { fromEvent } from '../projections/modelBound/fromEvent.js';
+import { entersOn } from '../projections/modelBound/entersOn.js';
+import { variantOf } from '../projections/modelBound/variantOf.js';
+import { reducer } from '../reducers/reducer.js';
+import { Reducers } from '../reducers/Reducers.js';
+import { index } from './indexDecorator.js';
+
+class IndexedEvent {}
+eventType('indexed-event')(IndexedEvent);
+
+class DeclarativeModel {
+    @field(String) @index() reference!: string;
+}
+@projection('indexed-declarative', DeclarativeModel)
+class DeclarativeProjection {
+    define(): void {}
+}
+
+@fromEvent(IndexedEvent)
+class ModelBoundModel {
+    @field(String) @index() reference!: string;
+}
+
+class VariantIdentity {}
+@variantOf(VariantIdentity, 'id')
+@entersOn(IndexedEvent)
+@fromEvent(IndexedEvent)
+class IndexedVariant {
+    @field(String) id!: string;
+    @field(String) @index() reference!: string;
+}
+
+class ReducedModel {
+    @field(String) @index() reference!: string;
+}
+@reducer('indexed-reducer', undefined, ReducedModel)
+class IndexedReducer {}
+
+function artifacts(readModels: IClientArtifactsProvider['readModels'] = [], projections: IClientArtifactsProvider['projections'] = [], reducers: IClientArtifactsProvider['reducers'] = []): IClientArtifactsProvider {
+    return {
+        eventTypes: [], readModels, projections, reducers, reactors: [], seeders: [], constraints: [],
+        webhooks: [], eventTypeMigrations: [], globalForHandlers: []
+    };
+}
+
+function connection() {
+    const registerMany = vi.fn().mockResolvedValue({});
+    const value = {
+        readModels: { registerMany },
+        projections: { register: vi.fn().mockResolvedValue({}) },
+        reducers: { observe: vi.fn().mockImplementation(async function* () {}) }
+    } as unknown as ChronicleConnection;
+    return { value, registerMany };
+}
+
+function indexesFor(registerMany: ReturnType<typeof vi.fn>, identifier: string) {
+    const definitions = registerMany.mock.calls[0][0].ReadModels as Array<{ Type: { Identifier: string }; Indexes: unknown[] }>;
+    return definitions.find(definition => definition.Type.Identifier === identifier)?.Indexes;
+}
+
+describe('when registering indexed read models through the startup paths', () => {
+    it('should send indexes for a declarative projection', async () => {
+        const { value, registerMany } = connection();
+        await new Projections('store', 'Default', value, artifacts([], [DeclarativeProjection]), 'sink').register();
+        expect(indexesFor(registerMany, 'DeclarativeModel')).toEqual([{ PropertyPath: 'reference' }]);
+    });
+
+    it('should send indexes for a model-bound projection', async () => {
+        const { value, registerMany } = connection();
+        await new Projections('store', 'Default', value, artifacts([ModelBoundModel]), 'sink').register();
+        expect(indexesFor(registerMany, 'ModelBoundModel')).toEqual([{ PropertyPath: 'reference' }]);
+    });
+
+    it('should send indexes for a model-bound variant', async () => {
+        const { value, registerMany } = connection();
+        await new Projections('store', 'Default', value, artifacts([IndexedVariant]), 'sink').register();
+        expect(indexesFor(registerMany, 'IndexedVariant')).toEqual([{ PropertyPath: 'reference' }]);
+    });
+
+    it('should send indexes for a reducer read model', async () => {
+        const { value, registerMany } = connection();
+        const reducers = new Reducers(artifacts([], [], [IndexedReducer]), value, 'store', 'Default', new ConnectionLifecycle(), 'sink');
+        await reducers.register();
+        reducers.dispose();
+        expect(indexesFor(registerMany, 'ReducedModel')).toEqual([{ PropertyPath: 'reference' }]);
+    });
+});

package/readModels/standardFallbacks.standard.spec.ts

@@ -2,6 +2,8 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { field } from '@cratis/fundamentals';
+import { fromEvent } from '../projections/modelBound/fromEvent.js';
+import { index } from './indexDecorator.js';
 import { describe, expect, it, vi } from 'vitest';
 import { IClientArtifactsProvider } from '../artifacts/IClientArtifactsProvider.js';
 import { ChronicleConnection } from '../connection/ChronicleConnection.js';
@@ -16,12 +18,41 @@ class UndecoratedModel {
 @reducer('undecorated-model', undefined, UndecoratedModel)
 class ModelReducer {}
 
+class IndexedEvent { value = ''; }
+
+class IndexedLine {
+    @field(String) @index() productId!: string;
+    @field(Number) quantity!: number;
+}
+
+@fromEvent(IndexedEvent)
+class IndexedOrder {
+    @field(String) id!: string;
+    @field(String) @index() customerId!: string;
+    @field(Array, { genericArguments: [IndexedLine] }) lines!: IndexedLine[];
+}
+
 const artifacts = {
     eventTypes: [], readModels: [], reactors: [], reducers: [ModelReducer], seeders: [],
     constraints: [], projections: [], webhooks: [], eventTypeMigrations: [], globalForHandlers: []
 } as IClientArtifactsProvider;
 
 describe('inferred read models with standard decorators', () => {
+    it('registers model-bound indexes on fields and typed collection elements as .NET property paths', async () => {
+        const registerMany = vi.fn().mockResolvedValue({});
+        const connection = { readModels: { registerMany } } as unknown as ChronicleConnection;
+        const provider = { ...artifacts, readModels: [IndexedOrder] };
+        await new ReadModels('test', 'Default', connection, provider, 'sink').register(IndexedOrder);
+        expect(registerMany).toHaveBeenCalledWith(expect.objectContaining({
+            ReadModels: [expect.objectContaining({
+                Indexes: [
+                    { PropertyPath: 'customerId' },
+                    { PropertyPath: 'lines.productId' }
+                ]
+            })]
+        }));
+    });
+
     it('rejects an untyped array before registering a reducer read model', async () => {
         const registerMany = vi.fn();
         const connection = { readModels: { registerMany } } as unknown as ChronicleConnection;

package/reducers/Reducers.ts

@@ -3,11 +3,10 @@
 
 import 'reflect-metadata';
 import { diag } from '@opentelemetry/api';
-import { Constructor, Guid } from '@cratis/fundamentals';
+import { Constructor } from '@cratis/fundamentals';
 import { ObservationState, ReadModelObserverType, ReducerMessage } from '@cratis/chronicle.contracts';
 import { IClientArtifactsProvider } from '../artifacts/index.js';
 import { ChronicleConnection } from '../connection/index.js';
-import { toContractsGuid } from '../connection/Guid.js';
 import { ConnectionLifecycle } from '../connection/ConnectionLifecycle.js';
 import { getEventTypeMetadata } from '../events/eventTypeDecorator.js';
 import { toClientEventContext } from '../events/toClientEventContext.js';
@@ -19,6 +18,7 @@ import { IReducers } from './IReducers.js';
 import { getReducerMetadata } from './reducer.js';
 import { getReadModelMetadata } from '../readModels/index.js';
 import { getReadModelId } from '../readModels/readModel.js';
+import { buildReadModelDefinition } from '../readModels/buildReadModelDefinition.js';
 import { assertUniqueReadModelIds } from '../readModels/assertUniqueReadModelIds.js';
 import { JsonSchemaGenerator } from '../schemas/index.js';
 
@@ -181,24 +181,14 @@ export class Reducers implements IReducers {
 
         const readModels = Array.from(this._reducers.entries()).map(([id, reducerType]) => {
             const readModelName = this.getReducerReadModelIdentifier(reducerType);
-            return {
-                Type: {
-                    Identifier: readModelName,
-                    Generation: 1
-                },
-                ContainerName: readModelName,
-                DisplayName: readModelName,
-                Sink: {
-                    ConfigurationId: toContractsGuid(Guid.empty),
-                    TypeId: this._defaultSinkTypeId
-                },
-                Schema: this.getReducerSchema(reducerType, readModelName),
-                Indexes: [],
-                ObserverType: ReadModelObserverType.Reducer,
-                ObserverIdentifier: id,
-                Owner: 1,
-                Source: 1
-            };
+            return buildReadModelDefinition({
+                identifier: readModelName,
+                type: getReducerMetadata(reducerType)?.readModel,
+                schema: this.getReducerSchema(reducerType, readModelName),
+                sinkTypeId: this._defaultSinkTypeId,
+                observerType: ReadModelObserverType.Reducer,
+                observerIdentifier: id
+            });
         });
 
         const identifiers = new Set<string>();