@cratis/chronicle 3.0.0 → 3.1.0

package/projections/declarative/AddChildBuilder.ts

@@ -0,0 +1,97 @@
+// 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 { IAddChildBuilder } from './IAddChildBuilder';
+
+/**
+ * A single `.addChild()` accumulation captured on a from/join builder, later merged into the
+ * owning projection builder's `Children` definitions once the enclosing `.from()`/`.join()`
+ * call resolves the event type it belongs to.
+ */
+export interface ChildAdditionEntry {
+    /** The read model property the child is added to. */
+    targetProperty: string;
+    /** The child model property used to identify instances, when set via the builder callback overload. */
+    identifiedBy?: string;
+    /** The event property used as the key, when set via the builder callback overload. */
+    usingKey?: string;
+    /** The event property whose value becomes the child directly, when set via the plain accessor overload. */
+    fromEventProperty?: string;
+}
+
+/**
+ * Implements {@link IAddChildBuilder} and doubles as a {@link ProxyHandler} so a single probe
+ * object can resolve `.addChild()`'s two call shapes at runtime: a plain event-property
+ * accessor (`e => e.someProperty`), or a builder callback (`b => b.usingKey(...)`). Known
+ * builder members are dispatched to the real implementation below; any other property access
+ * (the plain-accessor shape) falls through to the same path-capturing proxy used everywhere
+ * else in this file for `PropertyAccessor<T>` resolution.
+ * @template TChildModel - The child model type.
+ * @template TEvent - The event type.
+ */
+export class AddChildBuilder<TChildModel, TEvent> implements IAddChildBuilder<TChildModel, TEvent>, ProxyHandler<object> {
+    private readonly _pathHandler = new PropertyPathResolverProxyHandler();
+    private readonly _pathProxy = new Proxy({}, this._pathHandler);
+    private _usedAsBuilder = false;
+    private _identifiedByProperty: string | undefined;
+    private _usingKeyProperty: string | undefined;
+
+    /** Whether any builder member (`identifiedBy`/`usingKey`) was invoked on the probe. */
+    get usedAsBuilder(): boolean {
+        return this._usedAsBuilder;
+    }
+
+    /** The child model property captured via `identifiedBy()`, if any. */
+    get identifiedByProperty(): string | undefined {
+        return this._identifiedByProperty;
+    }
+
+    /** The event property captured via `usingKey()`, if any. */
+    get usingKeyProperty(): string | undefined {
+        return this._usingKeyProperty;
+    }
+
+    /** The event property path captured when the probe was used as a plain accessor. */
+    get capturedEventProperty(): string {
+        return this._pathHandler.property;
+    }
+
+    /** @inheritdoc */
+    identifiedBy(childPropertyAccessor: PropertyAccessor<TChildModel>): IAddChildBuilder<TChildModel, TEvent> {
+        this._usedAsBuilder = true;
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        childPropertyAccessor(proxy as TChildModel);
+        this._identifiedByProperty = handler.property;
+        return this;
+    }
+
+    /** @inheritdoc */
+    usingKey(eventPropertyAccessor: PropertyAccessor<TEvent>): IAddChildBuilder<TChildModel, TEvent> {
+        this._usedAsBuilder = true;
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        eventPropertyAccessor(proxy as TEvent);
+        this._usingKeyProperty = handler.property;
+        return this;
+    }
+
+    /**
+     * Proxy `get` trap: known builder members dispatch to the real implementation above;
+     * anything else (a plain event property accessed by the accessor overload) falls through
+     * to path-capturing so the accessor overload keeps working against the same probe.
+     * @param _target - The proxy's (unused) empty target object.
+     * @param prop - The accessed property name.
+     * @returns The resolved member.
+     */
+    get(_target: object, prop: string | symbol): unknown {
+        if (prop === 'identifiedBy') {
+            return this.identifiedBy.bind(this);
+        }
+        if (prop === 'usingKey') {
+            return this.usingKey.bind(this);
+        }
+        return Reflect.get(this._pathProxy as object, prop);
+    }
+}

package/projections/declarative/ChildrenBuilder.spec.ts

@@ -0,0 +1,157 @@
+// 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 LineAdded {
+    productId!: string;
+    quantity!: number;
+}
+eventType()(LineAdded);
+
+class TagAdded {
+    name!: string;
+}
+eventType()(TagAdded);
+
+class SummaryUpdated {
+    total!: number;
+}
+eventType()(SummaryUpdated);
+
+class SummaryCleared {}
+eventType()(SummaryCleared);
+
+class WholeLineReceived {
+    productId!: string;
+}
+eventType()(WholeLineReceived);
+
+class OrderLine {
+    productId!: string;
+    quantity!: number;
+}
+
+class OrderSummary {
+    total!: number;
+}
+
+class Order {
+    id!: string;
+    lines!: OrderLine[];
+    tags!: string[];
+    summary!: OrderSummary | undefined;
+}
+
+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 } }>;
+    FromEventProperty?: { Event: { Id: string } | undefined; PropertyExpression: string };
+}
+
+interface BuiltDefinition {
+    From: FromRecord[];
+    Children: Record<string, ChildrenDefinition>;
+    Nested: Record<string, ChildrenDefinition>;
+}
+
+describe('ChildrenBuilder and NestedBuilder', () => {
+    describe('when using children on the top-level builder', () => {
+        it('should produce a children definition keyed by the target property', () => {
+            const builder = new ProjectionBuilderFor<Order>();
+            builder.children<OrderLine>(order => order.lines, children => children
+                .identifiedBy(line => line.productId)
+                .from(LineAdded, from => from.set(line => line.quantity).to(event => event.quantity)));
+
+            const definition = builder.build('order', 'Order') as unknown as BuiltDefinition;
+            const linesDefinition = definition.Children.lines;
+
+            expect(linesDefinition.IdentifiedBy).toBe('productId');
+            const fromEntry = linesDefinition.From.find(candidate => candidate.Key.Id === 'LineAdded')!;
+            expect(fromEntry.Value.Properties.quantity).toBe('quantity');
+        });
+    });
+
+    describe('when using nested with clearWith on the top-level builder', () => {
+        it('should produce a nested definition with a RemovedWith entry', () => {
+            const builder = new ProjectionBuilderFor<Order>();
+            builder.nested<OrderSummary>(order => order.summary, nested => nested
+                .from(SummaryUpdated, from => from.set(summary => summary.total).to(event => event.total))
+                .clearWith(SummaryCleared));
+
+            const definition = builder.build('order', 'Order') as unknown as BuiltDefinition;
+            const summaryDefinition = definition.Nested.summary;
+
+            const fromEntry = summaryDefinition.From.find(candidate => candidate.Key.Id === 'SummaryUpdated')!;
+            expect(fromEntry.Value.Properties.total).toBe('total');
+            expect(summaryDefinition.RemovedWith[0].Key.Id).toBe('SummaryCleared');
+        });
+    });
+
+    describe('when using addChild with a builder callback', () => {
+        it('should produce a children definition keyed by identifiedBy and usingKey', () => {
+            const builder = new ProjectionBuilderFor<Order>();
+            builder.from(LineAdded, from => from.addChild<OrderLine>(order => order.lines, child => child
+                .identifiedBy(line => line.productId)
+                .usingKey(event => event.productId)));
+
+            const definition = builder.build('order', 'Order') as unknown as BuiltDefinition;
+            const linesDefinition = definition.Children.lines;
+
+            expect(linesDefinition.IdentifiedBy).toBe('productId');
+            const fromEntry = linesDefinition.From.find(candidate => candidate.Key.Id === 'LineAdded')!;
+            expect(fromEntry.Value.Key).toBe('productId');
+        });
+    });
+
+    describe('when using addChild with a plain event property accessor', () => {
+        it('should produce a children definition with a FromEventProperty expression', () => {
+            const builder = new ProjectionBuilderFor<Order>();
+            builder.from(TagAdded, from => from.addChild<string>(order => order.tags, event => event.name));
+
+            const definition = builder.build('order', 'Order') as unknown as BuiltDefinition;
+            const tagsDefinition = definition.Children.tags;
+
+            expect(tagsDefinition.FromEventProperty?.PropertyExpression).toBe('name');
+            expect(tagsDefinition.FromEventProperty?.Event?.Id).toBe('TagAdded');
+        });
+    });
+
+    describe('when using addChild on a join builder', () => {
+        it('should produce a children definition from the join clause', () => {
+            const builder = new ProjectionBuilderFor<Order>();
+            builder.join(WholeLineReceived, join => join.addChild<OrderLine>(order => order.lines, child => child
+                .identifiedBy(line => line.productId)));
+
+            const definition = builder.build('order', 'Order') as unknown as BuiltDefinition;
+            const linesDefinition = definition.Children.lines;
+
+            expect(linesDefinition.IdentifiedBy).toBe('productId');
+            expect(linesDefinition.From.some(candidate => candidate.Key.Id === 'WholeLineReceived')).toBe(true);
+        });
+    });
+
+    describe('when using setThisValue on a from builder', () => {
+        it('should map the whole event property onto the $this well-known expression', () => {
+            const builder = new ProjectionBuilderFor<Order>();
+            builder.from(TagAdded, from => from.setThisValue().to(event => event.name));
+
+            const definition = builder.build('order', 'Order') as unknown as BuiltDefinition;
+            const fromEntry = definition.From.find(candidate => candidate.Key.Id === 'TagAdded')!;
+
+            expect(fromEntry.Value.Properties.$this).toBe('name');
+        });
+    });
+});

package/projections/declarative/ChildrenBuilder.ts

@@ -0,0 +1,90 @@
+// 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 { NestedBuilder } from './NestedBuilder';
+
+/**
+ * Concrete implementation of {@link IChildrenBuilder}, building the `ChildrenDefinition` for a
+ * children collection sub-projection reached through `.children()`.
+ * @template TParentReadModel - The parent read model type.
+ * @template TChildReadModel - The child read model type.
+ */
+export class ChildrenBuilder<TParentReadModel, TChildReadModel>
+    extends ProjectionBuilderCore<TChildReadModel, IChildrenBuilder<TParentReadModel, TChildReadModel>>
+    implements IChildrenBuilder<TParentReadModel, TChildReadModel> {
+    private _identifiedBy: string | undefined;
+    private _fromEventPropertyPath: string | undefined;
+
+    /** @inheritdoc */
+    identifiedBy(propertyAccessor: PropertyAccessor<TChildReadModel>): IChildrenBuilder<TParentReadModel, TChildReadModel> {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        propertyAccessor(proxy as TChildReadModel);
+        this._identifiedBy = handler.property;
+        return this;
+    }
+
+    /** @inheritdoc */
+    fromEventProperty<TEvent>(propertyAccessor: PropertyAccessor<TEvent>): IChildrenBuilder<TParentReadModel, TChildReadModel> {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        propertyAccessor(proxy as TEvent);
+        this._fromEventPropertyPath = handler.property;
+        return this;
+    }
+
+    /** @inheritdoc */
+    children<TGrandchildModel>(
+        targetPropertyAccessor: PropertyAccessor<TChildReadModel>,
+        builderCallback: (builder: IChildrenBuilder<TChildReadModel, TGrandchildModel>) => void
+    ): IChildrenBuilder<TParentReadModel, TChildReadModel> {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        targetPropertyAccessor(proxy as TChildReadModel);
+
+        const builder = new ChildrenBuilder<TChildReadModel, TGrandchildModel>();
+        builderCallback(builder);
+        this._children[handler.property] = builder.buildDefinition();
+        return this;
+    }
+
+    /** @inheritdoc */
+    nested<TNestedModel>(
+        targetPropertyAccessor: PropertyAccessor<TChildReadModel>,
+        builderCallback: (builder: INestedBuilder<TChildReadModel, TNestedModel>) => void
+    ): IChildrenBuilder<TParentReadModel, TChildReadModel> {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        targetPropertyAccessor(proxy as TChildReadModel);
+
+        const builder = new NestedBuilder<TChildReadModel, TNestedModel>();
+        builderCallback(builder);
+        this._nested[handler.property] = builder.buildDefinition();
+        return this;
+    }
+
+    /**
+     * Builds the {@link ChildrenDefinitionLike} representing this children collection.
+     * @returns The accumulated children definition.
+     */
+    buildDefinition(): ChildrenDefinitionLike {
+        return {
+            IdentifiedBy: this._identifiedBy ?? '$eventSourceId',
+            From: this._from,
+            Join: this._join,
+            Children: this._children,
+            All: this._all,
+            FromEventProperty: this._fromEventPropertyPath === undefined
+                ? undefined
+                : { Event: undefined, PropertyExpression: this._fromEventPropertyPath },
+            RemovedWith: this._removedWith,
+            RemovedWithJoin: this._removedWithJoin,
+            AutoMap: this._autoMap,
+            Nested: this._nested
+        };
+    }
+}

package/projections/declarative/CompositeKeyBuilder.spec.ts

@@ -0,0 +1,117 @@
+// 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 OrderLineAdded {
+    orderId!: string;
+    lineNumber!: number;
+    quantity!: number;
+}
+eventType()(OrderLineAdded);
+
+class OrderLineJoined {
+    orderId!: string;
+    lineNumber!: number;
+    description!: string;
+}
+eventType()(OrderLineJoined);
+
+class CompositeKey {
+    orderId!: string;
+    lineNumber!: number;
+}
+
+class OrderLine {
+    id!: string;
+    quantity!: number;
+    description!: string;
+}
+
+interface FromRecord {
+    Key: { Id: string };
+    Value: { Key: string };
+}
+
+interface JoinRecord {
+    Key: { Id: string };
+    Value: { Key: string };
+}
+
+interface JoinRecordWithParentKey {
+    Key: { Id: string };
+    Value: { Key: string; ParentKey?: string };
+}
+
+describe('CompositeKeyBuilder', () => {
+    describe('when using a composite key on a from builder', () => {
+        it('should produce a $composite expression', () => {
+            const builder = new ProjectionBuilderFor<OrderLine>();
+            builder.from(OrderLineAdded, from => from.usingCompositeKey<CompositeKey>(key => key
+                .set(target => target.orderId, event => event.orderId)
+                .set(target => target.lineNumber, event => event.lineNumber)));
+
+            const definition = builder.build('orderLine', 'OrderLine') as unknown as { From: FromRecord[] };
+            const entry = definition.From.find(candidate => candidate.Key.Id === 'OrderLineAdded')!;
+
+            expect(entry.Value.Key).toBe('$composite(orderId=orderId,lineNumber=lineNumber)');
+        });
+    });
+
+    describe('when using a parent composite key on a from builder', () => {
+        it('should produce a $composite expression for the parent key', () => {
+            const builder = new ProjectionBuilderFor<OrderLine>();
+            builder.from(OrderLineAdded, from => from.usingParentCompositeKey<CompositeKey>(key => key
+                .set(target => target.orderId, event => event.orderId)
+                .set(target => target.lineNumber, event => event.lineNumber)));
+
+            const definition = builder.build('orderLine', 'OrderLine') as unknown as { From: Array<{ Key: { Id: string }; Value: { ParentKey: string } }> };
+            const entry = definition.From.find(candidate => candidate.Key.Id === 'OrderLineAdded')!;
+
+            expect(entry.Value.ParentKey).toBe('$composite(orderId=orderId,lineNumber=lineNumber)');
+        });
+    });
+
+    describe('when using a composite key on a join builder', () => {
+        it('should produce a $composite expression', () => {
+            const builder = new ProjectionBuilderFor<OrderLine>();
+            builder.join(OrderLineJoined, join => join
+                .on(model => model.id)
+                .usingCompositeKey<CompositeKey>(key => key
+                    .set(target => target.orderId, event => event.orderId)
+                    .set(target => target.lineNumber, event => event.lineNumber)));
+
+            const definition = builder.build('orderLine', 'OrderLine') as unknown as { Join: JoinRecord[] };
+            const entry = definition.Join.find(candidate => candidate.Key.Id === 'OrderLineJoined')!;
+
+            expect(entry.Value.Key).toBe('$composite(orderId=orderId,lineNumber=lineNumber)');
+        });
+    });
+
+    describe('when using parent-key methods on a join builder', () => {
+        it('should accept the calls without throwing, matching the C# client having no wire effect for Join', () => {
+            const builder = new ProjectionBuilderFor<OrderLine>();
+
+            expect(() => builder.join(OrderLineJoined, join => join
+                .on(model => model.id)
+                .usingParentKey(event => event.orderId)
+                .usingParentKeyFromContext('someContextProperty')
+                .usingParentCompositeKey<CompositeKey>(key => key.set(target => target.orderId, event => event.orderId))
+                .usingConstantParentKey('constant')
+            )).not.toThrow();
+
+            const definition = builder.build('orderLine', 'OrderLine') as unknown as { Join: JoinRecordWithParentKey[] };
+            const entry = definition.Join.find(candidate => candidate.Key.Id === 'OrderLineJoined')!;
+
+            // JoinDefinition has no ParentKey slot on the wire, so none of the calls above
+            // should have produced a ParentKey property.
+            expect(entry.Value.ParentKey).toBeUndefined();
+        });
+    });
+});

package/projections/declarative/CompositeKeyBuilder.ts

@@ -0,0 +1,38 @@
+// 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 { ICompositeKeyBuilder } from './ICompositeKeyBuilder';
+
+/**
+ * Concrete implementation of {@link ICompositeKeyBuilder} that builds a `$composite(...)` key
+ * expression from multiple event properties mapped onto named parts of a key type.
+ * @template TKeyType - The composite key type.
+ * @template TEvent - The event type.
+ */
+export class CompositeKeyBuilder<TKeyType, TEvent> implements ICompositeKeyBuilder<TKeyType, TEvent> {
+    private readonly _parts: Array<{ property: string; expression: string }> = [];
+
+    /** @inheritdoc */
+    set(
+        targetPropertyAccessor: PropertyAccessor<TKeyType>,
+        sourcePropertyAccessor: PropertyAccessor<TEvent>
+    ): ICompositeKeyBuilder<TKeyType, TEvent> {
+        const targetHandler = new PropertyPathResolverProxyHandler();
+        const targetProxy = new Proxy({}, targetHandler);
+        targetPropertyAccessor(targetProxy as TKeyType);
+
+        const sourceHandler = new PropertyPathResolverProxyHandler();
+        const sourceProxy = new Proxy({}, sourceHandler);
+        sourcePropertyAccessor(sourceProxy as TEvent);
+
+        this._parts.push({ property: targetHandler.property, expression: sourceHandler.property });
+        return this;
+    }
+
+    /** @inheritdoc */
+    build(): string {
+        const parts = this._parts.map(part => `${part.property}=${part.expression}`).join(',');
+        return `$composite(${parts})`;
+    }
+}

package/projections/declarative/FromBuilder.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 { IFromBuilder } from './IFromBuilder';
 import { ISetBuilder } from './ISetBuilder';
 import { ISubtractBuilder } from './ISubtractBuilder';
 import { SetBuilder } from './SetBuilder';
+import { SubtractBuilder } from './SubtractBuilder';
 
 /**
  * Accumulated property mapping for a from clause.
@@ -17,6 +21,7 @@ export interface FromEntry {
     properties: Record<string, string>;
     key: string;
     parentKey: string;
+    children: ChildAdditionEntry[];
 }
 
 /**
@@ -28,7 +33,8 @@ export class FromBuilder<TReadModel, TEvent> implements IFromBuilder<TReadModel,
     readonly entry: FromEntry = {
         properties: {},
         key: '$eventSourceId',
-        parentKey: ''
+        parentKey: '',
+        children: []
     };
 
     /** @inheritdoc */
@@ -75,13 +81,19 @@ export class FromBuilder<TReadModel, TEvent> implements IFromBuilder<TReadModel,
     }
 
     /** @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 implemented yet.');
+    usingParentCompositeKey<TKeyType>(builderCallback: (builder: ICompositeKeyBuilder<TKeyType, TEvent>) => void): this {
+        const compositeKeyBuilder = new CompositeKeyBuilder<TKeyType, TEvent>();
+        builderCallback(compositeKeyBuilder);
+        this.entry.parentKey = compositeKeyBuilder.build();
+        return this;
     }
 
     /** @inheritdoc */
@@ -115,30 +127,63 @@ export class FromBuilder<TReadModel, TEvent> implements IFromBuilder<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/ICompositeKeyBuilder.ts

@@ -19,4 +19,10 @@ export interface ICompositeKeyBuilder<TKeyType, TEvent> {
         targetPropertyAccessor: PropertyAccessor<TKeyType>,
         sourcePropertyAccessor: PropertyAccessor<TEvent>
     ): ICompositeKeyBuilder<TKeyType, TEvent>;
+
+    /**
+     * Builds the composite key expression from the configured parts.
+     * @returns The `$composite(...)` property expression.
+     */
+    build(): string;
 }