@cratis/chronicle 3.0.0 → 3.1.0

package/projections/Projections.childrenAndNested.spec.ts

@@ -0,0 +1,188 @@
+// 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 { IClientArtifactsProvider } from '../artifacts';
+import { ChronicleConnection } from '../connection';
+import { eventType } from '../events/eventTypeDecorator';
+import { readModel } from '../readModels/readModel';
+import { childrenFrom } from './modelBound/childrenFrom';
+import { clearWith } from './modelBound/clearWith';
+import { fromEvent } from './modelBound/fromEvent';
+import { nested } from './modelBound/nested';
+import { setFrom } from './modelBound/setFrom';
+import { Projections } from './Projections';
+
+// Decorators are applied as plain function calls (rather than `@decorator` syntax) so these
+// fixtures don't depend on the test runner's decorator-syntax support.
+
+class LineAdded {
+    productId!: string;
+    quantity!: number;
+}
+eventType()(LineAdded);
+
+class LineQuantityChanged {
+    quantity!: number;
+}
+eventType()(LineQuantityChanged);
+
+class SummaryUpdated {
+    total!: number;
+}
+eventType()(SummaryUpdated);
+
+class SummaryCleared {}
+eventType()(SummaryCleared);
+
+class NoteAdded {
+    text!: string;
+}
+eventType()(NoteAdded);
+
+class NoteCleared {}
+eventType()(NoteCleared);
+
+class TagAdded {
+    name!: string;
+}
+eventType()(TagAdded);
+
+class OrderCreated {}
+eventType()(OrderCreated);
+
+class OrderLine {
+    productId!: string;
+    quantity!: number;
+}
+setFrom(LineQuantityChanged)(OrderLine.prototype, 'quantity');
+
+class OrderSummary {
+    total!: number;
+}
+setFrom(SummaryUpdated)(OrderSummary.prototype, 'total');
+clearWith(SummaryCleared)(OrderSummary);
+
+class OrderNote {
+    text!: string;
+}
+setFrom(NoteAdded)(OrderNote.prototype, 'text');
+
+class Order {
+    id!: string;
+    lines!: OrderLine[];
+    summary!: OrderSummary | undefined;
+    note!: OrderNote | undefined;
+    tags!: string[];
+}
+childrenFrom(LineAdded, undefined, 'productId', undefined)(Order.prototype, 'lines');
+field(Array, { enumerable: true, genericArguments: [OrderLine] })(Order.prototype, 'lines');
+nested(Order.prototype, 'summary');
+field(OrderSummary)(Order.prototype, 'summary');
+nested(Order.prototype, 'note');
+field(OrderNote)(Order.prototype, 'note');
+clearWith(NoteCleared)(Order.prototype, 'note');
+childrenFrom(TagAdded)(Order.prototype, 'tags');
+fromEvent(OrderCreated)(Order);
+readModel()(Order);
+
+interface FromRecord {
+    Key: { Id: string };
+    Value: { Properties: Record<string, string>; Key: string; ParentKey: string };
+}
+
+interface ChildrenDefinition {
+    IdentifiedBy: string;
+    From: FromRecord[];
+    RemovedWith: Array<{ Key: { Id: string } }>;
+}
+
+interface BuiltDefinition {
+    Children: Record<string, ChildrenDefinition>;
+    Nested: Record<string, ChildrenDefinition>;
+}
+
+function createProjections(readModels: (new (...args: unknown[]) => unknown)[]) {
+    const registerMock = vi.fn().mockResolvedValue(undefined);
+    const registerManyMock = vi.fn().mockResolvedValue(undefined);
+    const connection = {
+        readModels: { registerMany: registerManyMock },
+        projections: { register: registerMock }
+    } as unknown as ChronicleConnection;
+
+    const clientArtifacts: IClientArtifactsProvider = {
+        eventTypes: [],
+        readModels: readModels as unknown as IClientArtifactsProvider['readModels'],
+        reactors: [],
+        reducers: [],
+        seeders: [],
+        constraints: [],
+        projections: [],
+        webhooks: [],
+        eventTypeMigrations: []
+    };
+
+    const projections = new Projections('test-store', connection, clientArtifacts, 'test-sink');
+    return { projections, registerMock };
+}
+
+describe('Projections with childrenFrom, nested and clearWith', () => {
+    describe('when registering a model-bound projection using them', () => {
+        it('should not throw', async () => {
+            const { projections } = createProjections([Order]);
+            await expect(projections.register()).resolves.not.toThrow();
+        });
+
+        it('should build a children definition with the resolved child type wired up', async () => {
+            const { projections, registerMock } = createProjections([Order]);
+            await projections.register();
+
+            const definition = registerMock.mock.calls[0][0].Projections[0] as BuiltDefinition;
+            const lines = definition.Children.lines;
+
+            expect(lines.IdentifiedBy).toBe('productId');
+            const creationEntry = lines.From.find(candidate => candidate.Key.Id === 'LineAdded')!;
+            expect(creationEntry.Value.Key).toBe('$eventSourceId');
+            expect(creationEntry.Value.ParentKey).toBe('$eventSourceId');
+
+            const updateEntry = lines.From.find(candidate => candidate.Key.Id === 'LineQuantityChanged')!;
+            expect(updateEntry.Value.Properties.quantity).toBe('quantity');
+        });
+
+        it('should build a children definition even when the child element type cannot be resolved', async () => {
+            const { projections, registerMock } = createProjections([Order]);
+            await projections.register();
+
+            const definition = registerMock.mock.calls[0][0].Projections[0] as BuiltDefinition;
+            const tags = definition.Children.tags;
+
+            expect(tags.From.some(candidate => candidate.Key.Id === 'TagAdded')).toBe(true);
+        });
+
+        it('should build a nested definition honoring a class-level clearWith on the nested type', async () => {
+            const { projections, registerMock } = createProjections([Order]);
+            await projections.register();
+
+            const definition = registerMock.mock.calls[0][0].Projections[0] as BuiltDefinition;
+            const summary = definition.Nested.summary;
+
+            const updateEntry = summary.From.find(candidate => candidate.Key.Id === 'SummaryUpdated')!;
+            expect(updateEntry.Value.Properties.total).toBe('total');
+            expect(summary.RemovedWith.some(candidate => candidate.Key.Id === 'SummaryCleared')).toBe(true);
+        });
+
+        it('should build a nested definition honoring a property-level clearWith', async () => {
+            const { projections, registerMock } = createProjections([Order]);
+            await projections.register();
+
+            const definition = registerMock.mock.calls[0][0].Projections[0] as BuiltDefinition;
+            const note = definition.Nested.note;
+
+            const updateEntry = note.From.find(candidate => candidate.Key.Id === 'NoteAdded')!;
+            expect(updateEntry.Value.Properties.text).toBe('text');
+            expect(note.RemovedWith.some(candidate => candidate.Key.Id === 'NoteCleared')).toBe(true);
+        });
+    });
+});

package/projections/Projections.spec.ts

@@ -0,0 +1,131 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { describe, expect, it, vi } from 'vitest';
+import { IClientArtifactsProvider } from '../artifacts';
+import { ChronicleConnection } from '../connection';
+import { eventType } from '../events/eventTypeDecorator';
+import { readModel } from '../readModels/readModel';
+import { addFrom } from './modelBound/addFrom';
+import { count } from './modelBound/count';
+import { decrement } from './modelBound/decrement';
+import { fromEvent } from './modelBound/fromEvent';
+import { increment } from './modelBound/increment';
+import { subtractFrom } from './modelBound/subtractFrom';
+import { Projections } from './Projections';
+
+// Decorators are applied as plain function calls (rather than `@decorator` syntax) so these
+// fixtures don't depend on the test runner's decorator-syntax support - they exercise exactly
+// the same decorator functions and metadata storage that `@decorator` syntax would invoke.
+
+class ItemAdded {
+    quantity!: number;
+}
+eventType()(ItemAdded);
+
+class ItemRemoved {
+    amount!: number;
+}
+eventType()(ItemRemoved);
+
+class CounterIncremented {}
+eventType()(CounterIncremented);
+
+class CounterDecremented {}
+eventType()(CounterDecremented);
+
+class ThingHappened {}
+eventType()(ThingHappened);
+
+class KeyedThingHappened {}
+eventType()(KeyedThingHappened);
+
+class Inventory {
+    id!: string;
+    total!: number;
+    totalFromNamedProperty!: number;
+    removedTotal!: number;
+    incrementedCount!: number;
+    decrementedCount!: number;
+    thingsHappenedCount!: number;
+    constantKeyedCount!: number;
+}
+addFrom(ItemAdded)(Inventory.prototype, 'total');
+addFrom(ItemAdded, 'quantity')(Inventory.prototype, 'totalFromNamedProperty');
+subtractFrom(ItemRemoved, 'amount')(Inventory.prototype, 'removedTotal');
+increment(CounterIncremented)(Inventory.prototype, 'incrementedCount');
+decrement(CounterDecremented)(Inventory.prototype, 'decrementedCount');
+count(ThingHappened)(Inventory.prototype, 'thingsHappenedCount');
+count(KeyedThingHappened, 'all-things')(Inventory.prototype, 'constantKeyedCount');
+fromEvent(ItemAdded)(Inventory);
+readModel()(Inventory);
+
+/**
+ * Builds a {@link Projections} instance wired to capture the registration payload sent
+ * to the kernel, without requiring a real gRPC connection.
+ */
+function createProjections(readModels: (new (...args: unknown[]) => unknown)[]) {
+    const registerMock = vi.fn().mockResolvedValue(undefined);
+    const registerManyMock = vi.fn().mockResolvedValue(undefined);
+    const connection = {
+        readModels: { registerMany: registerManyMock },
+        projections: { register: registerMock }
+    } as unknown as ChronicleConnection;
+
+    const clientArtifacts: IClientArtifactsProvider = {
+        eventTypes: [],
+        readModels: readModels as unknown as IClientArtifactsProvider['readModels'],
+        reactors: [],
+        reducers: [],
+        seeders: [],
+        constraints: [],
+        projections: [],
+        webhooks: [],
+        eventTypeMigrations: []
+    };
+
+    const projections = new Projections('test-store', connection, clientArtifacts, 'test-sink');
+    return { projections, registerMock };
+}
+
+function findFromEntry(definition: { From: Array<{ Key: { Id: string }; Value: { Properties: Record<string, string>; Key: string } }> }, eventTypeId: string) {
+    const entry = definition.From.find(candidate => candidate.Key.Id === eventTypeId);
+    if (!entry) {
+        throw new Error(`No From entry found for event type '${eventTypeId}'.`);
+    }
+    return entry;
+}
+
+describe('Projections', () => {
+    describe('when registering a model-bound projection with arithmetic decorators', () => {
+        it('should not throw and should produce the correct wire expressions', async () => {
+            const { projections, registerMock } = createProjections([Inventory]);
+
+            await expect(projections.register()).resolves.not.toThrow();
+
+            const request = registerMock.mock.calls[0][0] as { Projections: unknown[] };
+            const definition = request.Projections[0] as { From: Array<{ Key: { Id: string }; Value: { Properties: Record<string, string>; Key: string } }> };
+
+            const itemAdded = findFromEntry(definition, 'ItemAdded');
+            expect(itemAdded.Value.Properties.total).toBe('$add(total)');
+            expect(itemAdded.Value.Properties.totalFromNamedProperty).toBe('$add(quantity)');
+
+            const itemRemoved = findFromEntry(definition, 'ItemRemoved');
+            expect(itemRemoved.Value.Properties.removedTotal).toBe('$subtract(amount)');
+
+            const counterIncremented = findFromEntry(definition, 'CounterIncremented');
+            expect(counterIncremented.Value.Properties.incrementedCount).toBe('$increment');
+
+            const counterDecremented = findFromEntry(definition, 'CounterDecremented');
+            expect(counterDecremented.Value.Properties.decrementedCount).toBe('$decrement');
+
+            const thingHappened = findFromEntry(definition, 'ThingHappened');
+            expect(thingHappened.Value.Properties.thingsHappenedCount).toBe('$count');
+
+            const keyedThingHappened = findFromEntry(definition, 'KeyedThingHappened');
+            expect(keyedThingHappened.Value.Properties.constantKeyedCount).toBe('$count');
+            expect(keyedThingHappened.Value.Key).toBe('$value(all-things)');
+        });
+    });
+});

package/projections/Projections.ts

@@ -12,21 +12,25 @@ import { ChronicleConnection } from '../connection';
 import { toContractsGuid } from '../connection/Guid';
 import { WellKnownSinks } from '../sinks';
 import { EventSequenceId } from '../eventSequences/EventSequenceId';
-import { getEventTypeFor } from '../events/eventTypeDecorator';
 import { getReadModelMetadata } from '../readModels';
 import { TypeIntrospector } from '../types';
 import { IProjections } from './IProjections';
 import { getProjectionMetadata } from './declarative/projection';
 import { ProjectionBuilderFor } from './declarative/ProjectionBuilderFor';
 import type { IProjectionFor } from './declarative/IProjectionFor';
-import { getAddFromMetadata } from './modelBound/addFrom';
+import {
+    applyPropertyMappings,
+    buildChildrenEntry,
+    buildNestedEntry,
+    ChildrenDefinitionLike,
+    ContractEventType,
+    FromRecord,
+    getEventTypeMapKey,
+    toContractEventType
+} from './modelBound/childrenAndNestedBuilder';
 import { getChildrenFromMetadata } from './modelBound/childrenFrom';
-import { getClearWithClassMetadata, getClearWithPropertyMetadata } from './modelBound/clearWith';
-import { getCountMetadata } from './modelBound/count';
-import { getDecrementMetadata } from './modelBound/decrement';
 import { getFromEveryMetadata } from './modelBound/fromEvery';
 import { getFromEventMetadata, hasFromEventMetadata } from './modelBound/fromEvent';
-import { getIncrementMetadata } from './modelBound/increment';
 import { getJoinMetadata } from './modelBound/join';
 import { ProjectionId } from './ProjectionId';
 import { isNested } from './modelBound/nested';
@@ -34,12 +38,6 @@ import { isNotRewindable } from './modelBound/notRewindable';
 import { isPassive } from './modelBound/passive';
 import { getRemovedWithClassMetadata, getRemovedWithPropertyMetadata } from './modelBound/removedWith';
 import { getRemovedWithJoinClassMetadata, getRemovedWithJoinPropertyMetadata } from './modelBound/removedWithJoin';
-import { getSetFromMetadata } from './modelBound/setFrom';
-import { getSetFromContextMetadata } from './modelBound/setFromContext';
-import { getSetValueMetadata } from './modelBound/setValue';
-import { getSubtractFromMetadata } from './modelBound/subtractFrom';
-
-type ContractEventType = { Id: string; Generation: number; Tombstone: boolean };
 
 interface ResolvedModelBoundMetadata {
     id: ProjectionId;
@@ -277,15 +275,17 @@ export class Projections implements IProjections {
         const properties = TypeIntrospector.getTrackedProperties(type);
         const prototype = type.prototype;
 
-        const fromByEventType = new Map<string, { Key: ContractEventType; Value: { Properties: Record<string, string>; Key: string; ParentKey: string } }>();
+        const fromByEventType = new Map<string, FromRecord>();
         const joinByEventType = new Map<string, { Key: ContractEventType; Value: { On: string; Properties: Record<string, string>; Key: string } }>();
         const removedWithByEventType = new Map<string, { Key: ContractEventType; Value: { Key: string; ParentKey: string } }>();
         const removedWithJoinByEventType = new Map<string, { Key: ContractEventType; Value: { Key: string } }>();
+        const childrenByProperty: Record<string, ChildrenDefinitionLike> = {};
+        const nestedByProperty: Record<string, ChildrenDefinitionLike> = {};
 
         const fromEvents = getFromEventMetadata(type);
         for (const fromEvent of fromEvents) {
-            const eventType = this.toContractEventType(fromEvent.eventType);
-            const eventKey = this.getEventTypeMapKey(eventType);
+            const eventType = toContractEventType(fromEvent.eventType);
+            const eventKey = getEventTypeMapKey(eventType);
             fromByEventType.set(eventKey, {
                 Key: eventType,
                 Value: {
@@ -296,15 +296,10 @@ export class Projections implements IProjections {
             });
         }
 
-        const clearWithClass = getClearWithClassMetadata(type);
-        if (clearWithClass.length > 0) {
-            throw new Error(`Model-bound projection '${type.name}' uses @clearWith on class level, which is not implemented yet.`);
-        }
-
         const removedWithClass = getRemovedWithClassMetadata(type);
         for (const removed of removedWithClass) {
-            const eventType = this.toContractEventType(removed.eventType);
-            removedWithByEventType.set(this.getEventTypeMapKey(eventType), {
+            const eventType = toContractEventType(removed.eventType);
+            removedWithByEventType.set(getEventTypeMapKey(eventType), {
                 Key: eventType,
                 Value: { Key: removed.key ?? '$eventSourceId', ParentKey: removed.parentKey ?? '' }
             });
@@ -312,30 +307,15 @@ export class Projections implements IProjections {
 
         const removedWithJoinClass = getRemovedWithJoinClassMetadata(type);
         for (const removed of removedWithJoinClass) {
-            const eventType = this.toContractEventType(removed.eventType);
-            removedWithJoinByEventType.set(this.getEventTypeMapKey(eventType), {
+            const eventType = toContractEventType(removed.eventType);
+            removedWithJoinByEventType.set(getEventTypeMapKey(eventType), {
                 Key: eventType,
                 Value: { Key: removed.key ?? '$eventSourceId' }
             });
         }
 
         for (const property of properties) {
-            this.throwIfUnsupportedModelBoundDecorators(type.name, prototype, property);
-
-            for (const mapping of getSetFromMetadata(prototype, property)) {
-                const entry = this.ensureFromEntry(fromByEventType, mapping.eventType);
-                entry.Value.Properties[property] = mapping.eventPropertyName ?? property;
-            }
-
-            for (const mapping of getSetFromContextMetadata(prototype, property)) {
-                const entry = this.ensureFromEntry(fromByEventType, mapping.eventType);
-                entry.Value.Properties[property] = mapping.contextPropertyName ?? property;
-            }
-
-            for (const mapping of getSetValueMetadata(prototype, property)) {
-                const entry = this.ensureFromEntry(fromByEventType, mapping.eventType);
-                entry.Value.Properties[property] = JSON.stringify(mapping.value);
-            }
+            applyPropertyMappings(prototype, property, fromByEventType);
 
             for (const mapping of getJoinMetadata(prototype, property)) {
                 const entry = this.ensureJoinEntry(joinByEventType, mapping.eventType);
@@ -343,26 +323,30 @@ export class Projections implements IProjections {
                 entry.Value.Properties[property] = mapping.eventPropertyName ?? property;
             }
 
-            const fromEvery = getFromEveryMetadata(prototype, property);
-            if (fromEvery) {
-                // Applied later to projection.All
-            }
-
             for (const removed of getRemovedWithPropertyMetadata(prototype, property)) {
-                const eventType = this.toContractEventType(removed.eventType);
-                removedWithByEventType.set(this.getEventTypeMapKey(eventType), {
+                const eventType = toContractEventType(removed.eventType);
+                removedWithByEventType.set(getEventTypeMapKey(eventType), {
                     Key: eventType,
                     Value: { Key: removed.key ?? '$eventSourceId', ParentKey: removed.parentKey ?? '' }
                 });
             }
 
             for (const removed of getRemovedWithJoinPropertyMetadata(prototype, property)) {
-                const eventType = this.toContractEventType(removed.eventType);
-                removedWithJoinByEventType.set(this.getEventTypeMapKey(eventType), {
+                const eventType = toContractEventType(removed.eventType);
+                removedWithJoinByEventType.set(getEventTypeMapKey(eventType), {
                     Key: eventType,
                     Value: { Key: removed.key ?? '$eventSourceId' }
                 });
             }
+
+            const childrenFromList = getChildrenFromMetadata(prototype, property);
+            if (childrenFromList.length > 0) {
+                childrenByProperty[property] = buildChildrenEntry(type, property, childrenFromList);
+            }
+
+            if (isNested(prototype, property)) {
+                nestedByProperty[property] = buildNestedEntry(type, property);
+            }
         }
 
         const allProperties: Record<string, string> = {};
@@ -384,7 +368,7 @@ export class Projections implements IProjections {
             InitialModelState: '{}',
             From: Array.from(fromByEventType.values()),
             Join: Array.from(joinByEventType.values()),
-            Children: {},
+            Children: childrenByProperty,
             FromEvery: [],
             All: {
                 Properties: allProperties,
@@ -396,7 +380,7 @@ export class Projections implements IProjections {
             LastUpdated: { Value: '' },
             Tags: [],
             AutoMap: AutoMap.Enabled,
-            Nested: {}
+            Nested: nestedByProperty
         };
         definition.LastUpdated = { Value: this.computeStableLastUpdated(definition) };
         return definition;
@@ -416,62 +400,12 @@ export class Projections implements IProjections {
         return undefined;
     }
 
-    private throwIfUnsupportedModelBoundDecorators(typeName: string, prototype: object, property: string): void {
-        if (getAddFromMetadata(prototype, property).length > 0) {
-            throw new Error(`Model-bound projection '${typeName}' uses @addFrom on '${property}', which is not implemented yet.`);
-        }
-        if (getSubtractFromMetadata(prototype, property).length > 0) {
-            throw new Error(`Model-bound projection '${typeName}' uses @subtractFrom on '${property}', which is not implemented yet.`);
-        }
-        if (getIncrementMetadata(prototype, property).length > 0) {
-            throw new Error(`Model-bound projection '${typeName}' uses @increment on '${property}', which is not implemented yet.`);
-        }
-        if (getDecrementMetadata(prototype, property).length > 0) {
-            throw new Error(`Model-bound projection '${typeName}' uses @decrement on '${property}', which is not implemented yet.`);
-        }
-        if (getCountMetadata(prototype, property).length > 0) {
-            throw new Error(`Model-bound projection '${typeName}' uses @count on '${property}', which is not implemented yet.`);
-        }
-        if (getChildrenFromMetadata(prototype, property).length > 0) {
-            throw new Error(`Model-bound projection '${typeName}' uses @childrenFrom on '${property}', which is not implemented yet.`);
-        }
-        if (isNested(prototype, property)) {
-            throw new Error(`Model-bound projection '${typeName}' uses @nested on '${property}', which is not implemented yet.`);
-        }
-        if (getClearWithPropertyMetadata(prototype, property).length > 0) {
-            throw new Error(`Model-bound projection '${typeName}' uses @clearWith on '${property}', which is not implemented yet.`);
-        }
-    }
-
-    private ensureFromEntry(
-        fromByEventType: Map<string, { Key: ContractEventType; Value: { Properties: Record<string, string>; Key: string; ParentKey: string } }>,
-        eventTypeConstructor: Function
-    ): { Key: ContractEventType; Value: { Properties: Record<string, string>; Key: string; ParentKey: string } } {
-        const eventType = this.toContractEventType(eventTypeConstructor);
-        const key = this.getEventTypeMapKey(eventType);
-        const existing = fromByEventType.get(key);
-        if (existing) {
-            return existing;
-        }
-
-        const created = {
-            Key: eventType,
-            Value: {
-                Properties: {},
-                Key: '$eventSourceId',
-                ParentKey: ''
-            }
-        };
-        fromByEventType.set(key, created);
-        return created;
-    }
-
     private ensureJoinEntry(
         joinByEventType: Map<string, { Key: ContractEventType; Value: { On: string; Properties: Record<string, string>; Key: string } }>,
         eventTypeConstructor: Function
     ): { Key: ContractEventType; Value: { On: string; Properties: Record<string, string>; Key: string } } {
-        const eventType = this.toContractEventType(eventTypeConstructor);
-        const key = this.getEventTypeMapKey(eventType);
+        const eventType = toContractEventType(eventTypeConstructor);
+        const key = getEventTypeMapKey(eventType);
         const existing = joinByEventType.get(key);
         if (existing) {
             return existing;
@@ -489,22 +423,6 @@ export class Projections implements IProjections {
         return created;
     }
 
-    private toContractEventType(eventTypeConstructor: Function): ContractEventType {
-        const eventType = getEventTypeFor(eventTypeConstructor);
-        if (eventType.id.value === '') {
-            throw new Error(`Event type '${eventTypeConstructor.name}' is not decorated with @eventType().`);
-        }
-        return {
-            Id: eventType.id.value,
-            Generation: eventType.generation.value,
-            Tombstone: false
-        };
-    }
-
-    private getEventTypeMapKey(eventType: ContractEventType): string {
-        return `${eventType.Id}:${eventType.Generation}:${eventType.Tombstone ? '1' : '0'}`;
-    }
-
     /**
      * Computes a stable, deterministic ISO timestamp from the projection definition content,
      * excluding the LastUpdated field itself. This ensures the server does not interpret

package/projections/declarative/AddBuilder.ts

@@ -0,0 +1,28 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { PropertyAccessor, PropertyPathResolverProxyHandler } from '@cratis/fundamentals';
+import { IAddBuilder } from './IAddBuilder';
+
+/**
+ * Concrete implementation of {@link IAddBuilder} that records an add expression
+ * into the owning from/join builder.
+ * @template TEvent - The event type.
+ * @template TParentBuilder - The parent builder type.
+ */
+export class AddBuilder<TEvent, TParentBuilder> implements IAddBuilder<TEvent, TParentBuilder> {
+    constructor(
+        private readonly _readModelProperty: string,
+        private readonly _setProperty: (readModelProp: string, expression: string) => void,
+        private readonly _parent: TParentBuilder
+    ) {}
+
+    /** @inheritdoc */
+    with(eventPropertyAccessor: PropertyAccessor<TEvent>): TParentBuilder {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        eventPropertyAccessor(proxy as TEvent);
+        this._setProperty(this._readModelProperty, `$add(${handler.property})`);
+        return this._parent;
+    }
+}