@cratis/chronicle 2.1.1 → 3.1.0

package/projections/declarative/JoinBuilder.ts

@@ -2,6 +2,9 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { PropertyAccessor, PropertyPathResolverProxyHandler } from '@cratis/fundamentals';
+import { AddBuilder } from './AddBuilder';
+import { AddChildBuilder, ChildAdditionEntry } from './AddChildBuilder';
+import { CompositeKeyBuilder } from './CompositeKeyBuilder';
 import { IAddBuilder } from './IAddBuilder';
 import { IAddChildBuilder } from './IAddChildBuilder';
 import { ICompositeKeyBuilder } from './ICompositeKeyBuilder';
@@ -9,6 +12,7 @@ import { IJoinBuilder } from './IJoinBuilder';
 import { ISetBuilder } from './ISetBuilder';
 import { ISubtractBuilder } from './ISubtractBuilder';
 import { SetBuilder } from './SetBuilder';
+import { SubtractBuilder } from './SubtractBuilder';
 
 /**
  * Accumulated property mapping for a join clause.
@@ -17,6 +21,7 @@ export interface JoinEntry {
     on: string;
     properties: Record<string, string>;
     key: string;
+    children: ChildAdditionEntry[];
 }
 
 /**
@@ -28,7 +33,8 @@ export class JoinBuilder<TReadModel, TEvent> implements IJoinBuilder<TReadModel,
     readonly entry: JoinEntry = {
         on: '',
         properties: {},
-        key: '$eventSourceId'
+        key: '$eventSourceId',
+        children: []
     };
 
     /** @inheritdoc */
@@ -71,22 +77,31 @@ export class JoinBuilder<TReadModel, TEvent> implements IJoinBuilder<TReadModel,
 
     /** @inheritdoc */
     usingParentKey(_keyAccessor: PropertyAccessor<TEvent>): this {
-        throw new Error('usingParentKey is not supported for join mappings.');
+        // A join's wire definition (JoinDefinition) has no ParentKey slot - the C# client
+        // accepts this call too (it is inherited from the shared key-builder base) but its
+        // JoinBuilder.Build() only ever reads On/Properties/Key, so the value is silently
+        // unused there as well. Matching that: accept the call, but it has no effect.
+        return this;
     }
 
     /** @inheritdoc */
     usingParentKeyFromContext(_contextPropertyName: string): this {
-        throw new Error('usingParentKeyFromContext is not supported for join mappings.');
+        // See usingParentKey - accepted for interface parity with From, no wire effect for Join.
+        return this;
     }
 
     /** @inheritdoc */
-    usingCompositeKey<TKeyType>(_builderCallback: (builder: ICompositeKeyBuilder<TKeyType, TEvent>) => void): this {
-        throw new Error('usingCompositeKey is not implemented yet.');
+    usingCompositeKey<TKeyType>(builderCallback: (builder: ICompositeKeyBuilder<TKeyType, TEvent>) => void): this {
+        const compositeKeyBuilder = new CompositeKeyBuilder<TKeyType, TEvent>();
+        builderCallback(compositeKeyBuilder);
+        this.entry.key = compositeKeyBuilder.build();
+        return this;
     }
 
     /** @inheritdoc */
     usingParentCompositeKey<TKeyType>(_builderCallback: (builder: ICompositeKeyBuilder<TKeyType, TEvent>) => void): this {
-        throw new Error('usingParentCompositeKey is not supported for join mappings.');
+        // See usingParentKey - accepted for interface parity with From, no wire effect for Join.
+        return this;
     }
 
     /** @inheritdoc */
@@ -97,7 +112,8 @@ export class JoinBuilder<TReadModel, TEvent> implements IJoinBuilder<TReadModel,
 
     /** @inheritdoc */
     usingConstantParentKey(_value: string): this {
-        throw new Error('usingConstantParentKey is not supported for join mappings.');
+        // See usingParentKey - accepted for interface parity with From, no wire effect for Join.
+        return this;
     }
 
     /** @inheritdoc */
@@ -119,30 +135,63 @@ export class JoinBuilder<TReadModel, TEvent> implements IJoinBuilder<TReadModel,
     }
 
     /** @inheritdoc */
-    add(_readModelPropertyAccessor: PropertyAccessor<TReadModel>): IAddBuilder<TEvent, this> {
-        throw new Error('add is not implemented yet.');
+    add(readModelPropertyAccessor: PropertyAccessor<TReadModel>): IAddBuilder<TEvent, this> {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        readModelPropertyAccessor(proxy as TReadModel);
+        return new AddBuilder<TEvent, this>(
+            handler.property,
+            (property, expression) => { this.entry.properties[property] = expression; },
+            this
+        );
     }
 
     /** @inheritdoc */
-    subtract(_readModelPropertyAccessor: PropertyAccessor<TReadModel>): ISubtractBuilder<TEvent, this> {
-        throw new Error('subtract is not implemented yet.');
+    subtract(readModelPropertyAccessor: PropertyAccessor<TReadModel>): ISubtractBuilder<TEvent, this> {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        readModelPropertyAccessor(proxy as TReadModel);
+        return new SubtractBuilder<TEvent, this>(
+            handler.property,
+            (property, expression) => { this.entry.properties[property] = expression; },
+            this
+        );
     }
 
     /** @inheritdoc */
-    count(_readModelPropertyAccessor: PropertyAccessor<TReadModel>): this {
-        throw new Error('count is not implemented yet.');
+    count(readModelPropertyAccessor: PropertyAccessor<TReadModel>): this {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        readModelPropertyAccessor(proxy as TReadModel);
+        this.entry.properties[handler.property] = '$count';
+        return this;
     }
 
     /** @inheritdoc */
     addChild<TChildModel>(
-        _targetPropertyAccessor: PropertyAccessor<TReadModel>,
-        _eventPropertyAccessorOrBuilderCallback: PropertyAccessor<TEvent> | ((builder: IAddChildBuilder<TChildModel, TEvent>) => void)
+        targetPropertyAccessor: PropertyAccessor<TReadModel>,
+        eventPropertyAccessorOrBuilderCallback: PropertyAccessor<TEvent> | ((builder: IAddChildBuilder<TChildModel, TEvent>) => void)
     ): this {
-        throw new Error('addChild is not implemented yet.');
+        const targetHandler = new PropertyPathResolverProxyHandler();
+        const targetProxy = new Proxy({}, targetHandler);
+        targetPropertyAccessor(targetProxy as TReadModel);
+
+        const probe = new AddChildBuilder<TChildModel, TEvent>();
+        const probeProxy = new Proxy({}, probe);
+        (eventPropertyAccessorOrBuilderCallback as (value: unknown) => void)(probeProxy);
+
+        this.entry.children.push(probe.usedAsBuilder
+            ? { targetProperty: targetHandler.property, identifiedBy: probe.identifiedByProperty, usingKey: probe.usingKeyProperty }
+            : { targetProperty: targetHandler.property, fromEventProperty: probe.capturedEventProperty });
+        return this;
     }
 
     /** @inheritdoc */
     setThisValue(): ISetBuilder<TEvent, this> {
-        throw new Error('setThisValue is not implemented yet.');
+        return new SetBuilder<TEvent, this>(
+            '$this',
+            (rp, expr) => { this.entry.properties[rp] = expr; },
+            this
+        );
     }
 }

package/projections/declarative/NestedBuilder.ts

@@ -0,0 +1,76 @@
+// 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 { ChildrenDefinitionLike, ProjectionBuilderCore } from './ProjectionBuilderCore';
+import { IChildrenBuilder } from './IChildrenBuilder';
+import { INestedBuilder } from './INestedBuilder';
+import { ChildrenBuilder } from './ChildrenBuilder';
+
+/**
+ * Concrete implementation of {@link INestedBuilder}, building the `ChildrenDefinition` for a
+ * nested single-object sub-projection reached through `.nested()`.
+ * @template TParentReadModel - The parent read model type.
+ * @template TNestedReadModel - The nested object read model type.
+ */
+export class NestedBuilder<TParentReadModel, TNestedReadModel>
+    extends ProjectionBuilderCore<TNestedReadModel, INestedBuilder<TParentReadModel, TNestedReadModel>>
+    implements INestedBuilder<TParentReadModel, TNestedReadModel> {
+    /** @inheritdoc */
+    clearWith(eventType: Function): INestedBuilder<TParentReadModel, TNestedReadModel> {
+        const contractType = this.toContractEventType(eventType);
+        this._removedWith.push({
+            Key: contractType,
+            Value: { Key: '$eventSourceId', ParentKey: '' }
+        });
+        return this;
+    }
+
+    /** @inheritdoc */
+    children<TChildModel>(
+        targetPropertyAccessor: PropertyAccessor<TNestedReadModel>,
+        builderCallback: (builder: IChildrenBuilder<TNestedReadModel, TChildModel>) => void
+    ): INestedBuilder<TParentReadModel, TNestedReadModel> {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        targetPropertyAccessor(proxy as TNestedReadModel);
+
+        const builder = new ChildrenBuilder<TNestedReadModel, TChildModel>();
+        builderCallback(builder);
+        this._children[handler.property] = builder.buildDefinition();
+        return this;
+    }
+
+    /** @inheritdoc */
+    nested<TGrandNestedModel>(
+        targetPropertyAccessor: PropertyAccessor<TNestedReadModel>,
+        builderCallback: (builder: INestedBuilder<TNestedReadModel, TGrandNestedModel>) => void
+    ): INestedBuilder<TParentReadModel, TNestedReadModel> {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        targetPropertyAccessor(proxy as TNestedReadModel);
+
+        const builder = new NestedBuilder<TNestedReadModel, TGrandNestedModel>();
+        builderCallback(builder);
+        this._nested[handler.property] = builder.buildDefinition();
+        return this;
+    }
+
+    /**
+     * Builds the {@link ChildrenDefinitionLike} representing this nested object.
+     * @returns The accumulated nested definition.
+     */
+    buildDefinition(): ChildrenDefinitionLike {
+        return {
+            IdentifiedBy: '',
+            From: this._from,
+            Join: this._join,
+            Children: this._children,
+            All: this._all,
+            RemovedWith: this._removedWith,
+            RemovedWithJoin: this._removedWithJoin,
+            AutoMap: this._autoMap,
+            Nested: this._nested
+        };
+    }
+}

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