@cratis/chronicle 3.0.0 → 3.1.1

package/projections/declarative/ProjectionBuilderCore.ts

@@ -0,0 +1,257 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { AutoMap } from '@cratis/chronicle.contracts';
+import { getEventTypeFor } from '../../events/eventTypeDecorator';
+import { FromBuilder } from './FromBuilder';
+import { IFromBuilder } from './IFromBuilder';
+import { IFromEveryBuilder } from './IFromEveryBuilder';
+import { IJoinBuilder } from './IJoinBuilder';
+import { IRemovedWithBuilder } from './IRemovedWithBuilder';
+import { IRemovedWithJoinBuilder } from './IRemovedWithJoinBuilder';
+import { JoinBuilder } from './JoinBuilder';
+import { FromEveryBuilder } from './FromEveryBuilder';
+import { RemovedWithBuilder } from './RemovedWithBuilder';
+import { RemovedWithJoinBuilder } from './RemovedWithJoinBuilder';
+import { ChildAdditionEntry } from './AddChildBuilder';
+
+/** The contract-level event type identifier shape used across projection definitions. */
+export type ContractEventType = { Id: string; Generation: number; Tombstone: boolean };
+
+/** Accumulated property mapping for a from clause. */
+export interface FromRecord {
+    Key: ContractEventType;
+    Value: { Properties: Record<string, string>; Key: string; ParentKey: string };
+}
+
+/** Accumulated property mapping for a join clause. */
+export interface JoinRecord {
+    Key: ContractEventType;
+    Value: { On: string; Properties: Record<string, string>; Key: string };
+}
+
+/** Accumulated removal mapping for a removedWith clause. */
+export interface RemovedWithRecord {
+    Key: ContractEventType;
+    Value: { Key: string; ParentKey: string };
+}
+
+/** Accumulated removal mapping for a removedWithJoin clause. */
+export interface RemovedWithJoinRecord {
+    Key: ContractEventType;
+    Value: { Key: string };
+}
+
+/**
+ * Plain object shape matching the wire-level `ChildrenDefinition` used for both children
+ * collections and nested single-object projections.
+ */
+export interface ChildrenDefinitionLike {
+    IdentifiedBy: string;
+    From: FromRecord[];
+    Join: JoinRecord[];
+    Children: Record<string, ChildrenDefinitionLike>;
+    All: { Properties: Record<string, string>; IncludeChildren: boolean; AutoMap: AutoMap };
+    FromEventProperty?: { Event: ContractEventType | undefined; PropertyExpression: string };
+    RemovedWith: RemovedWithRecord[];
+    RemovedWithJoin: RemovedWithJoinRecord[];
+    AutoMap: AutoMap;
+    Nested: Record<string, ChildrenDefinitionLike>;
+}
+
+/**
+ * Base accumulator shared by every projection-shaped builder (the top-level
+ * {@link ProjectionBuilderFor}, and the child/nested builders reached through
+ * `.children()`/`.nested()`). Holds the from/join/fromEvery/removedWith/removedWithJoin/
+ * children/nested state and the mapping operations common to all of them, mirroring the
+ * shared `ProjectionBuilder<TReadModel, TBuilder>` base class on the C# client.
+ * @template TReadModel - The read model type this builder produces.
+ * @template TBuilder - The concrete builder type returned for fluent chaining.
+ */
+export abstract class ProjectionBuilderCore<TReadModel, TBuilder> {
+    protected _autoMap: AutoMap = AutoMap.Inherit;
+    protected _initialState: string = '{}';
+    protected readonly _from: FromRecord[] = [];
+    protected readonly _join: JoinRecord[] = [];
+    protected readonly _removedWith: RemovedWithRecord[] = [];
+    protected readonly _removedWithJoin: RemovedWithJoinRecord[] = [];
+    protected readonly _children: Record<string, ChildrenDefinitionLike> = {};
+    protected readonly _nested: Record<string, ChildrenDefinitionLike> = {};
+    protected _all: { Properties: Record<string, string>; IncludeChildren: boolean; AutoMap: AutoMap } = {
+        Properties: {},
+        IncludeChildren: false,
+        AutoMap: AutoMap.Inherit
+    };
+
+    /** @inheritdoc */
+    autoMap(): TBuilder {
+        this._autoMap = AutoMap.Enabled;
+        return this as unknown as TBuilder;
+    }
+
+    /** @inheritdoc */
+    noAutoMap(): TBuilder {
+        this._autoMap = AutoMap.Disabled;
+        return this as unknown as TBuilder;
+    }
+
+    /** @inheritdoc */
+    withInitialValues(initialValueProvider: () => TReadModel): TBuilder {
+        this._initialState = JSON.stringify(initialValueProvider());
+        return this as unknown as TBuilder;
+    }
+
+    /** @inheritdoc */
+    from<TEvent>(
+        eventType: new (...args: any[]) => TEvent,
+        builderCallback?: (builder: IFromBuilder<TReadModel, TEvent>) => void
+    ): TBuilder {
+        const contractType = this.toContractEventType(eventType);
+        const fromBuilder = new FromBuilder<TReadModel, TEvent>();
+        builderCallback?.(fromBuilder);
+        this._from.push({
+            Key: contractType,
+            Value: {
+                Properties: fromBuilder.entry.properties,
+                Key: fromBuilder.entry.key,
+                ParentKey: fromBuilder.entry.parentKey
+            }
+        });
+        this.mergeChildAdditions(contractType, fromBuilder.entry.children);
+        return this as unknown as TBuilder;
+    }
+
+    /** @inheritdoc */
+    join<TEvent>(
+        eventType: new (...args: any[]) => TEvent,
+        builderCallback?: (builder: IJoinBuilder<TReadModel, TEvent>) => void
+    ): TBuilder {
+        const contractType = this.toContractEventType(eventType);
+        const joinBuilder = new JoinBuilder<TReadModel, TEvent>();
+        builderCallback?.(joinBuilder);
+        this._join.push({
+            Key: contractType,
+            Value: {
+                On: joinBuilder.entry.on,
+                Properties: joinBuilder.entry.properties,
+                Key: joinBuilder.entry.key
+            }
+        });
+        this.mergeChildAdditions(contractType, joinBuilder.entry.children);
+        return this as unknown as TBuilder;
+    }
+
+    /** @inheritdoc */
+    fromEvery(builderCallback: (builder: IFromEveryBuilder<TReadModel>) => void): TBuilder {
+        const builder = new FromEveryBuilder<TReadModel>();
+        builderCallback(builder);
+        this._all = {
+            Properties: {
+                ...this._all.Properties,
+                ...builder.entry.properties
+            },
+            IncludeChildren: builder.entry.includeChildren,
+            AutoMap: AutoMap.Inherit
+        };
+        return this as unknown as TBuilder;
+    }
+
+    /** @inheritdoc */
+    removedWith<TEvent>(
+        eventType: new (...args: any[]) => TEvent,
+        builderCallback?: (builder: IRemovedWithBuilder<TReadModel, TEvent>) => void
+    ): TBuilder {
+        const contractType = this.toContractEventType(eventType);
+        const removedWithBuilder = new RemovedWithBuilder<TReadModel, TEvent>();
+        builderCallback?.(removedWithBuilder);
+        this._removedWith.push({
+            Key: contractType,
+            Value: {
+                Key: removedWithBuilder.entry.key,
+                ParentKey: removedWithBuilder.entry.parentKey
+            }
+        });
+        return this as unknown as TBuilder;
+    }
+
+    /** @inheritdoc */
+    removedWithJoin<TEvent>(
+        eventType: new (...args: any[]) => TEvent,
+        builderCallback?: (builder: IRemovedWithJoinBuilder<TReadModel, TEvent>) => void
+    ): TBuilder {
+        const contractType = this.toContractEventType(eventType);
+        const removedWithJoinBuilder = new RemovedWithJoinBuilder<TReadModel, TEvent>();
+        builderCallback?.(removedWithJoinBuilder);
+        this._removedWithJoin.push({
+            Key: contractType,
+            Value: {
+                Key: removedWithJoinBuilder.entry.key
+            }
+        });
+        return this as unknown as TBuilder;
+    }
+
+    /**
+     * Creates an empty {@link ChildrenDefinitionLike} accumulator for a children/nested entry.
+     * @returns A fresh, empty children definition.
+     */
+    protected createEmptyChildrenDefinition(): ChildrenDefinitionLike {
+        return {
+            IdentifiedBy: '$eventSourceId',
+            From: [],
+            Join: [],
+            Children: {},
+            All: { Properties: {}, IncludeChildren: false, AutoMap: AutoMap.Inherit },
+            RemovedWith: [],
+            RemovedWithJoin: [],
+            AutoMap: AutoMap.Inherit,
+            Nested: {}
+        };
+    }
+
+    /**
+     * Merges `.addChild()` accumulations captured on a from/join builder into this builder's
+     * children definitions, creating the target child entry on first use.
+     * @param eventType - The contract event type the child additions were captured for.
+     * @param children - The accumulated child additions.
+     */
+    private mergeChildAdditions(eventType: ContractEventType, children: ChildAdditionEntry[]): void {
+        for (const child of children) {
+            const childDefinition = this._children[child.targetProperty] ??= this.createEmptyChildrenDefinition();
+
+            if (child.identifiedBy) {
+                childDefinition.IdentifiedBy = child.identifiedBy;
+            }
+
+            if (child.fromEventProperty) {
+                childDefinition.FromEventProperty = { Event: eventType, PropertyExpression: child.fromEventProperty };
+            }
+
+            childDefinition.From.push({
+                Key: eventType,
+                Value: {
+                    Key: child.usingKey ?? '$eventSourceId',
+                    ParentKey: '$eventSourceId',
+                    Properties: {}
+                }
+            });
+        }
+    }
+
+    /**
+     * Resolves the contract event type for a decorated event constructor.
+     * @param eventTypeConstructor - The event class constructor.
+     * @returns The contract-level event type identifier.
+     */
+    protected 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
+        };
+    }
+}

package/projections/declarative/ProjectionBuilderFor.spec.ts

@@ -0,0 +1,115 @@
+// 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 } from 'vitest';
+import { eventType } from '../../events/eventTypeDecorator';
+import { ProjectionBuilderFor } from './ProjectionBuilderFor';
+
+// 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 ItemAdded {
+    quantity!: number;
+}
+eventType()(ItemAdded);
+
+class ItemRemoved {
+    quantity!: number;
+}
+eventType()(ItemRemoved);
+
+class ThingHappened {}
+eventType()(ThingHappened);
+
+class Inventory {
+    id!: string;
+    total!: number;
+    removedTotal!: number;
+    thingsHappenedCount!: number;
+}
+
+interface FromRecord {
+    Key: { Id: string };
+    Value: { Properties: Record<string, string>; Key: string };
+}
+
+interface JoinRecord {
+    Key: { Id: string };
+    Value: { Properties: Record<string, string> };
+}
+
+describe('ProjectionBuilderFor', () => {
+    describe('when using add on a from builder', () => {
+        it('should produce a $add expression targeting the event property', () => {
+            const builder = new ProjectionBuilderFor<Inventory>();
+            builder.from(ItemAdded, from => from.add(model => model.total).with(event => event.quantity));
+
+            const definition = builder.build('inventory', 'Inventory') as unknown as { From: FromRecord[] };
+            const entry = definition.From.find(candidate => candidate.Key.Id === 'ItemAdded')!;
+
+            expect(entry.Value.Properties.total).toBe('$add(quantity)');
+        });
+    });
+
+    describe('when using subtract on a from builder', () => {
+        it('should produce a $subtract expression targeting the event property', () => {
+            const builder = new ProjectionBuilderFor<Inventory>();
+            builder.from(ItemRemoved, from => from.subtract(model => model.removedTotal).with(event => event.quantity));
+
+            const definition = builder.build('inventory', 'Inventory') as unknown as { From: FromRecord[] };
+            const entry = definition.From.find(candidate => candidate.Key.Id === 'ItemRemoved')!;
+
+            expect(entry.Value.Properties.removedTotal).toBe('$subtract(quantity)');
+        });
+    });
+
+    describe('when using count on a from builder', () => {
+        it('should produce a $count expression and return the builder for chaining', () => {
+            const builder = new ProjectionBuilderFor<Inventory>();
+            builder.from(ThingHappened, from => from.count(model => model.thingsHappenedCount).usingConstantKey('singleton'));
+
+            const definition = builder.build('inventory', 'Inventory') as unknown as { From: FromRecord[] };
+            const entry = definition.From.find(candidate => candidate.Key.Id === 'ThingHappened')!;
+
+            expect(entry.Value.Properties.thingsHappenedCount).toBe('$count');
+            expect(entry.Value.Key).toBe('singleton');
+        });
+    });
+
+    describe('when using add on a join builder', () => {
+        it('should produce a $add expression targeting the event property', () => {
+            const builder = new ProjectionBuilderFor<Inventory>();
+            builder.join(ItemAdded, join => join.add(model => model.total).with(event => event.quantity));
+
+            const definition = builder.build('inventory', 'Inventory') as unknown as { Join: JoinRecord[] };
+            const entry = definition.Join.find(candidate => candidate.Key.Id === 'ItemAdded')!;
+
+            expect(entry.Value.Properties.total).toBe('$add(quantity)');
+        });
+    });
+
+    describe('when using subtract on a join builder', () => {
+        it('should produce a $subtract expression targeting the event property', () => {
+            const builder = new ProjectionBuilderFor<Inventory>();
+            builder.join(ItemRemoved, join => join.subtract(model => model.removedTotal).with(event => event.quantity));
+
+            const definition = builder.build('inventory', 'Inventory') as unknown as { Join: JoinRecord[] };
+            const entry = definition.Join.find(candidate => candidate.Key.Id === 'ItemRemoved')!;
+
+            expect(entry.Value.Properties.removedTotal).toBe('$subtract(quantity)');
+        });
+    });
+
+    describe('when using count on a join builder', () => {
+        it('should produce a $count expression', () => {
+            const builder = new ProjectionBuilderFor<Inventory>();
+            builder.join(ThingHappened, join => join.count(model => model.thingsHappenedCount));
+
+            const definition = builder.build('inventory', 'Inventory') as unknown as { Join: JoinRecord[] };
+            const entry = definition.Join.find(candidate => candidate.Key.Id === 'ThingHappened')!;
+
+            expect(entry.Value.Properties.thingsHappenedCount).toBe('$count');
+        });
+    });
+});

package/projections/declarative/ProjectionBuilderFor.ts

@@ -2,65 +2,30 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { AutoMap } from '@cratis/chronicle.contracts';
-import { getEventTypeFor } from '../../events/eventTypeDecorator';
+import { PropertyAccessor, PropertyPathResolverProxyHandler } from '@cratis/fundamentals';
 import { EventSequenceId } from '../../eventSequences/EventSequenceId';
+import { ChildrenBuilder } from './ChildrenBuilder';
 import { IChildrenBuilder } from './IChildrenBuilder';
-import { IFromBuilder } from './IFromBuilder';
-import { IFromEveryBuilder } from './IFromEveryBuilder';
-import { IJoinBuilder } from './IJoinBuilder';
 import { INestedBuilder } from './INestedBuilder';
 import { IProjectionBuilderFor } from './IProjectionBuilderFor';
-import { IRemovedWithBuilder } from './IRemovedWithBuilder';
-import { IRemovedWithJoinBuilder } from './IRemovedWithJoinBuilder';
-import { JoinBuilder } from './JoinBuilder';
-import { FromEveryBuilder } from './FromEveryBuilder';
-import { FromBuilder } from './FromBuilder';
-import { RemovedWithBuilder } from './RemovedWithBuilder';
-import { RemovedWithJoinBuilder } from './RemovedWithJoinBuilder';
-
-type ContractEventType = { Id: string; Generation: number; Tombstone: boolean };
-
-interface FromRecord {
-    Key: ContractEventType;
-    Value: { Properties: Record<string, string>; Key: string; ParentKey: string };
-}
-
-interface RemovedWithRecord {
-    Key: ContractEventType;
-    Value: { Key: string; ParentKey: string };
-}
-
-interface JoinRecord {
-    Key: ContractEventType;
-    Value: { On: string; Properties: Record<string, string>; Key: string };
-}
-
-interface RemovedWithJoinRecord {
-    Key: ContractEventType;
-    Value: { Key: string };
-}
+import { NestedBuilder } from './NestedBuilder';
+import { ProjectionBuilderCore } from './ProjectionBuilderCore';
 
 /**
  * Concrete implementation of {@link IProjectionBuilderFor} that accumulates projection
  * configuration and produces a Chronicle-compatible projection definition payload.
  * @template TReadModel - The read model type this projection produces.
  */
-export class ProjectionBuilderFor<TReadModel> implements IProjectionBuilderFor<TReadModel> {
+export class ProjectionBuilderFor<TReadModel> extends ProjectionBuilderCore<TReadModel, ProjectionBuilderFor<TReadModel>> implements IProjectionBuilderFor<TReadModel> {
     private _eventSequenceId: string = EventSequenceId.eventLog.value;
     private _containerName: string | undefined;
     private _rewindable: boolean = true;
     private _active: boolean = true;
-    private _autoMap: AutoMap = AutoMap.Enabled;
-    private _initialState: string = '{}';
-    private readonly _from: FromRecord[] = [];
-    private readonly _join: JoinRecord[] = [];
-    private readonly _removedWith: RemovedWithRecord[] = [];
-    private readonly _removedWithJoin: RemovedWithJoinRecord[] = [];
-    private _all: { Properties: Record<string, string>; IncludeChildren: boolean; AutoMap: AutoMap } = {
-        Properties: {},
-        IncludeChildren: false,
-        AutoMap: AutoMap.Inherit
-    };
+
+    constructor() {
+        super();
+        this._autoMap = AutoMap.Enabled;
+    }
 
     /** @inheritdoc */
     fromEventSequence(eventSequenceId: string): this {
@@ -87,127 +52,35 @@ export class ProjectionBuilderFor<TReadModel> implements IProjectionBuilderFor<T
     }
 
     /** @inheritdoc */
-    autoMap(): this {
-        this._autoMap = AutoMap.Enabled;
-        return this;
-    }
-
-    /** @inheritdoc */
-    noAutoMap(): this {
-        this._autoMap = AutoMap.Disabled;
-        return this;
-    }
-
-    /** @inheritdoc */
-    withInitialValues(initialValueProvider: () => TReadModel): this {
-        this._initialState = JSON.stringify(initialValueProvider());
-        return this;
-    }
-
-    /** @inheritdoc */
-    from<TEvent>(
-        eventType: new (...args: any[]) => TEvent,
-        builderCallback?: (builder: IFromBuilder<TReadModel, TEvent>) => void
-    ): this {
-        const contractType = this.toContractEventType(eventType);
-        const fromBuilder = new FromBuilder<TReadModel, TEvent>();
-        builderCallback?.(fromBuilder);
-        this._from.push({
-            Key: contractType,
-            Value: {
-                Properties: fromBuilder.entry.properties,
-                Key: fromBuilder.entry.key,
-                ParentKey: fromBuilder.entry.parentKey
-            }
-        });
-        return this;
-    }
-
-    /** @inheritdoc */
-    join<TEvent>(
-        eventType: new (...args: any[]) => TEvent,
-        builderCallback?: (builder: IJoinBuilder<TReadModel, TEvent>) => void
+    children<TChildModel>(
+        targetPropertyAccessor: PropertyAccessor<TReadModel>,
+        builderCallback: (builder: IChildrenBuilder<TReadModel, TChildModel>) => void
     ): this {
-        const contractType = this.toContractEventType(eventType);
-        const joinBuilder = new JoinBuilder<TReadModel, TEvent>();
-        builderCallback?.(joinBuilder);
-        this._join.push({
-            Key: contractType,
-            Value: {
-                On: joinBuilder.entry.on,
-                Properties: joinBuilder.entry.properties,
-                Key: joinBuilder.entry.key
-            }
-        });
-        return this;
-    }
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        targetPropertyAccessor(proxy as TReadModel);
 
-    /** @inheritdoc */
-    fromEvery(builderCallback: (builder: IFromEveryBuilder<TReadModel>) => void): this {
-        const builder = new FromEveryBuilder<TReadModel>();
+        const builder = new ChildrenBuilder<TReadModel, TChildModel>();
         builderCallback(builder);
-        this._all = {
-            Properties: {
-                ...this._all.Properties,
-                ...builder.entry.properties
-            },
-            IncludeChildren: builder.entry.includeChildren,
-            AutoMap: AutoMap.Inherit
-        };
+        this._children[handler.property] = builder.buildDefinition();
         return this;
     }
 
     /** @inheritdoc */
-    removedWith<TEvent>(
-        eventType: new (...args: any[]) => TEvent,
-        builderCallback?: (builder: IRemovedWithBuilder<TReadModel, TEvent>) => void
+    nested<TNestedModel>(
+        targetPropertyAccessor: PropertyAccessor<TReadModel>,
+        builderCallback: (builder: INestedBuilder<TReadModel, TNestedModel>) => void
     ): this {
-        const contractType = this.toContractEventType(eventType);
-        const removedWithBuilder = new RemovedWithBuilder<TReadModel, TEvent>();
-        builderCallback?.(removedWithBuilder);
-        this._removedWith.push({
-            Key: contractType,
-            Value: {
-                Key: removedWithBuilder.entry.key,
-                ParentKey: removedWithBuilder.entry.parentKey
-            }
-        });
-        return this;
-    }
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        targetPropertyAccessor(proxy as TReadModel);
 
-    /** @inheritdoc */
-    removedWithJoin<TEvent>(
-        eventType: new (...args: any[]) => TEvent,
-        builderCallback?: (builder: IRemovedWithJoinBuilder<TReadModel, TEvent>) => void
-    ): this {
-        const contractType = this.toContractEventType(eventType);
-        const removedWithJoinBuilder = new RemovedWithJoinBuilder<TReadModel, TEvent>();
-        builderCallback?.(removedWithJoinBuilder);
-        this._removedWithJoin.push({
-            Key: contractType,
-            Value: {
-                Key: removedWithJoinBuilder.entry.key
-            }
-        });
+        const builder = new NestedBuilder<TReadModel, TNestedModel>();
+        builderCallback(builder);
+        this._nested[handler.property] = builder.buildDefinition();
         return this;
     }
 
-    /** @inheritdoc */
-    children<TChildModel>(
-        _targetPropertyAccessor: any,
-        _builderCallback: (builder: IChildrenBuilder<TReadModel, TChildModel>) => void
-    ): this {
-        throw new Error('children is not implemented yet.');
-    }
-
-    /** @inheritdoc */
-    nested<TNestedModel>(
-        _targetPropertyAccessor: any,
-        _builderCallback: (builder: INestedBuilder<TReadModel, TNestedModel>) => void
-    ): this {
-        throw new Error('nested is not implemented yet.');
-    }
-
     /**
      * Builds the contract-compatible projection definition payload.
      * @param identifier - The projection identifier.
@@ -224,7 +97,7 @@ export class ProjectionBuilderFor<TReadModel> implements IProjectionBuilderFor<T
             InitialModelState: this._initialState,
             From: this._from,
             Join: this._join,
-            Children: {},
+            Children: this._children,
             FromEvery: [],
             All: this._all,
             FromEventProperty: undefined,
@@ -233,7 +106,7 @@ export class ProjectionBuilderFor<TReadModel> implements IProjectionBuilderFor<T
             LastUpdated: { Value: '' },
             Tags: [],
             AutoMap: this._autoMap,
-            Nested: {}
+            Nested: this._nested
         };
         definition.LastUpdated = { Value: this.computeStableLastUpdated(definition) };
         return definition;
@@ -265,18 +138,6 @@ export class ProjectionBuilderFor<TReadModel> implements IProjectionBuilderFor<T
         return Array.from(mappedProperties.values());
     }
 
-    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
-        };
-    }
-
     /**
      * 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/SubtractBuilder.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 { ISubtractBuilder } from './ISubtractBuilder';
+
+/**
+ * Concrete implementation of {@link ISubtractBuilder} that records a subtract expression
+ * into the owning from/join builder.
+ * @template TEvent - The event type.
+ * @template TParentBuilder - The parent builder type.
+ */
+export class SubtractBuilder<TEvent, TParentBuilder> implements ISubtractBuilder<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, `$subtract(${handler.property})`);
+        return this._parent;
+    }
+}

package/projections/declarative/index.ts

@@ -4,8 +4,17 @@
 export { projection, getProjectionMetadata, isProjection } from './projection';
 export type { ProjectionMetadata } from './projection';
 export { ProjectionBuilderFor } from './ProjectionBuilderFor';
+export { ProjectionBuilderCore } from './ProjectionBuilderCore';
+export { ChildrenBuilder } from './ChildrenBuilder';
+export { NestedBuilder } from './NestedBuilder';
+export { AddChildBuilder } from './AddChildBuilder';
+export type { ChildAdditionEntry } from './AddChildBuilder';
+export { CompositeKeyBuilder } from './CompositeKeyBuilder';
 export { FromBuilder } from './FromBuilder';
+export { JoinBuilder } from './JoinBuilder';
 export { SetBuilder } from './SetBuilder';
+export { AddBuilder } from './AddBuilder';
+export { SubtractBuilder } from './SubtractBuilder';
 export { RemovedWithBuilder } from './RemovedWithBuilder';
 export type { IProjectionFor } from './IProjectionFor';
 export type { IProjectionBuilderFor } from './IProjectionBuilderFor';