@cratis/chronicle 0.0.1

package/Projections/declarative/JoinBuilder.ts

@@ -0,0 +1,148 @@
+// 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';
+import { IAddChildBuilder } from './IAddChildBuilder';
+import { ICompositeKeyBuilder } from './ICompositeKeyBuilder';
+import { IJoinBuilder } from './IJoinBuilder';
+import { ISetBuilder } from './ISetBuilder';
+import { ISubtractBuilder } from './ISubtractBuilder';
+import { SetBuilder } from './SetBuilder';
+
+/**
+ * Accumulated property mapping for a join clause.
+ */
+export interface JoinEntry {
+    on: string;
+    properties: Record<string, string>;
+    key: string;
+}
+
+/**
+ * Concrete implementation of {@link IJoinBuilder}.
+ * @template TReadModel - The read model type.
+ * @template TEvent - The event type.
+ */
+export class JoinBuilder<TReadModel, TEvent> implements IJoinBuilder<TReadModel, TEvent> {
+    readonly entry: JoinEntry = {
+        on: '',
+        properties: {},
+        key: '$eventSourceId'
+    };
+
+    /** @inheritdoc */
+    on(readModelPropertyAccessor: PropertyAccessor<TReadModel>): this {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        readModelPropertyAccessor(proxy as TReadModel);
+        this.entry.on = handler.property;
+        return this;
+    }
+
+    /** @inheritdoc */
+    set(readModelPropertyAccessor: PropertyAccessor<TReadModel>): ISetBuilder<TEvent, IJoinBuilder<TReadModel, TEvent>> {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        readModelPropertyAccessor(proxy as TReadModel);
+        const readModelProperty = handler.property;
+
+        return new SetBuilder<TEvent, IJoinBuilder<TReadModel, TEvent>>(
+            readModelProperty,
+            (property, expression) => { this.entry.properties[property] = expression; },
+            this
+        );
+    }
+
+    /** @inheritdoc */
+    usingKey(keyAccessor: PropertyAccessor<TEvent>): this {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        keyAccessor(proxy as TEvent);
+        this.entry.key = handler.property;
+        return this;
+    }
+
+    /** @inheritdoc */
+    usingKeyFromContext(contextPropertyName: string): this {
+        this.entry.key = `$context.${contextPropertyName}`;
+        return this;
+    }
+
+    /** @inheritdoc */
+    usingParentKey(_keyAccessor: PropertyAccessor<TEvent>): this {
+        throw new Error('usingParentKey is not supported for join mappings.');
+    }
+
+    /** @inheritdoc */
+    usingParentKeyFromContext(_contextPropertyName: string): this {
+        throw new Error('usingParentKeyFromContext is not supported for join mappings.');
+    }
+
+    /** @inheritdoc */
+    usingCompositeKey<TKeyType>(_builderCallback: (builder: ICompositeKeyBuilder<TKeyType, TEvent>) => void): this {
+        throw new Error('usingCompositeKey is not implemented yet.');
+    }
+
+    /** @inheritdoc */
+    usingParentCompositeKey<TKeyType>(_builderCallback: (builder: ICompositeKeyBuilder<TKeyType, TEvent>) => void): this {
+        throw new Error('usingParentCompositeKey is not supported for join mappings.');
+    }
+
+    /** @inheritdoc */
+    usingConstantKey(value: string): this {
+        this.entry.key = value;
+        return this;
+    }
+
+    /** @inheritdoc */
+    usingConstantParentKey(_value: string): this {
+        throw new Error('usingConstantParentKey is not supported for join mappings.');
+    }
+
+    /** @inheritdoc */
+    increment(readModelPropertyAccessor: PropertyAccessor<TReadModel>): this {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        readModelPropertyAccessor(proxy as TReadModel);
+        this.entry.properties[handler.property] = '$increment';
+        return this;
+    }
+
+    /** @inheritdoc */
+    decrement(readModelPropertyAccessor: PropertyAccessor<TReadModel>): this {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        readModelPropertyAccessor(proxy as TReadModel);
+        this.entry.properties[handler.property] = '$decrement';
+        return this;
+    }
+
+    /** @inheritdoc */
+    add(_readModelPropertyAccessor: PropertyAccessor<TReadModel>): IAddBuilder<TEvent, this> {
+        throw new Error('add is not implemented yet.');
+    }
+
+    /** @inheritdoc */
+    subtract(_readModelPropertyAccessor: PropertyAccessor<TReadModel>): ISubtractBuilder<TEvent, this> {
+        throw new Error('subtract is not implemented yet.');
+    }
+
+    /** @inheritdoc */
+    count(_readModelPropertyAccessor: PropertyAccessor<TReadModel>): this {
+        throw new Error('count is not implemented yet.');
+    }
+
+    /** @inheritdoc */
+    addChild<TChildModel>(
+        _targetPropertyAccessor: PropertyAccessor<TReadModel>,
+        _eventPropertyAccessorOrBuilderCallback: PropertyAccessor<TEvent> | ((builder: IAddChildBuilder<TChildModel, TEvent>) => void)
+    ): this {
+        throw new Error('addChild is not implemented yet.');
+    }
+
+    /** @inheritdoc */
+    setThisValue(): ISetBuilder<TEvent, this> {
+        throw new Error('setThisValue is not implemented yet.');
+    }
+}

package/Projections/declarative/ProjectionBuilderFor.ts

@@ -0,0 +1,277 @@
+// 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 { EventSequenceId } from '../../EventSequences/EventSequenceId';
+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 };
+}
+
+/**
+ * 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> {
+    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
+    };
+
+    /** @inheritdoc */
+    fromEventSequence(eventSequenceId: string): this {
+        this._eventSequenceId = eventSequenceId;
+        return this;
+    }
+
+    /** @inheritdoc */
+    containerName(name: string): this {
+        this._containerName = name;
+        return this;
+    }
+
+    /** @inheritdoc */
+    notRewindable(): this {
+        this._rewindable = false;
+        return this;
+    }
+
+    /** @inheritdoc */
+    passive(): this {
+        this._active = false;
+        return this;
+    }
+
+    /** @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
+    ): 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;
+    }
+
+    /** @inheritdoc */
+    fromEvery(builderCallback: (builder: IFromEveryBuilder<TReadModel>) => void): this {
+        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;
+    }
+
+    /** @inheritdoc */
+    removedWith<TEvent>(
+        eventType: new (...args: any[]) => TEvent,
+        builderCallback?: (builder: IRemovedWithBuilder<TReadModel, TEvent>) => 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;
+    }
+
+    /** @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
+            }
+        });
+        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.
+     * @param readModelName - The read model container name.
+     * @returns The projection definition object ready to send to the kernel.
+     */
+    build(identifier: string, readModelName: string): Record<string, unknown> {
+        return {
+            EventSequenceId: this._eventSequenceId,
+            Identifier: identifier,
+            ReadModel: this._containerName ?? readModelName,
+            IsActive: this._active,
+            IsRewindable: this._rewindable,
+            InitialModelState: this._initialState,
+            From: this._from,
+            Join: this._join,
+            Children: {},
+            FromEvery: [],
+            All: this._all,
+            FromEventProperty: undefined,
+            RemovedWith: this._removedWith,
+            RemovedWithJoin: this._removedWithJoin,
+            LastUpdated: { Value: new Date().toISOString() },
+            Tags: [],
+            AutoMap: this._autoMap,
+            Nested: {}
+        };
+    }
+
+    /**
+     * Gets the set of read model properties referenced by configured mappings.
+     * @returns Unique read model property names used by from/join/fromEvery mappings.
+     */
+    getMappedReadModelProperties(): string[] {
+        const mappedProperties = new Set<string>();
+
+        for (const from of this._from) {
+            for (const property of Object.keys(from.Value.Properties)) {
+                mappedProperties.add(property);
+            }
+        }
+
+        for (const join of this._join) {
+            for (const property of Object.keys(join.Value.Properties)) {
+                mappedProperties.add(property);
+            }
+        }
+
+        for (const property of Object.keys(this._all.Properties)) {
+            mappedProperties.add(property);
+        }
+
+        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
+        };
+    }
+}

package/Projections/declarative/RemovedWithBuilder.ts

@@ -0,0 +1,40 @@
+// 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 { IRemovedWithBuilder } from './IRemovedWithBuilder';
+
+/**
+ * Accumulated removal configuration for a removedWith clause.
+ */
+export interface RemovedWithEntry {
+    key: string;
+    parentKey: string;
+}
+
+/**
+ * Concrete implementation of {@link IRemovedWithBuilder}.
+ * @template TReadModel - The read model type.
+ * @template TEvent - The event type.
+ */
+export class RemovedWithBuilder<TReadModel, TEvent> implements IRemovedWithBuilder<TReadModel, TEvent> {
+    readonly entry: RemovedWithEntry = {
+        key: '$eventSourceId',
+        parentKey: ''
+    };
+
+    /** @inheritdoc */
+    usingKey(keyAccessor: PropertyAccessor<TEvent>): this {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        keyAccessor(proxy as TEvent);
+        this.entry.key = handler.property;
+        return this;
+    }
+
+    /** @inheritdoc */
+    usingKeyFromContext(contextPropertyName: string): this {
+        this.entry.key = `$context.${contextPropertyName}`;
+        return this;
+    }
+}

package/Projections/declarative/RemovedWithJoinBuilder.ts

@@ -0,0 +1,43 @@
+// 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 { IRemovedWithJoinBuilder } from './IRemovedWithJoinBuilder';
+
+/**
+ * Accumulated removal configuration for a removedWithJoin clause.
+ */
+export interface RemovedWithJoinEntry {
+    on: string;
+    key: string;
+}
+
+/**
+ * Concrete implementation of {@link IRemovedWithJoinBuilder}.
+ * @template TReadModel - The read model type.
+ * @template TEvent - The event type.
+ */
+export class RemovedWithJoinBuilder<TReadModel, TEvent> implements IRemovedWithJoinBuilder<TReadModel, TEvent> {
+    readonly entry: RemovedWithJoinEntry = {
+        on: '',
+        key: '$eventSourceId'
+    };
+
+    /** @inheritdoc */
+    on(readModelPropertyAccessor: PropertyAccessor<TReadModel>): this {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        readModelPropertyAccessor(proxy as TReadModel);
+        this.entry.on = handler.property;
+        return this;
+    }
+
+    /** @inheritdoc */
+    usingKey(keyAccessor: PropertyAccessor<TEvent>): this {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        keyAccessor(proxy as TEvent);
+        this.entry.key = handler.property;
+        return this;
+    }
+}

package/Projections/declarative/SetBuilder.ts

@@ -0,0 +1,46 @@
+// 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 { ISetBuilder } from './ISetBuilder';
+
+/**
+ * Concrete implementation of {@link ISetBuilder} that records the property mapping
+ * into the owning from/join builder.
+ * @template TEvent - The event type.
+ * @template TParentBuilder - The parent builder type.
+ */
+export class SetBuilder<TEvent, TParentBuilder> implements ISetBuilder<TEvent, TParentBuilder> {
+    constructor(
+        private readonly _readModelProperty: string,
+        private readonly _setProperty: (readModelProp: string, expression: string) => void,
+        private readonly _parent: TParentBuilder
+    ) {}
+
+    /** @inheritdoc */
+    to(eventPropertyAccessor: PropertyAccessor<TEvent>): TParentBuilder {
+        const handler = new PropertyPathResolverProxyHandler();
+        const proxy = new Proxy({}, handler);
+        eventPropertyAccessor(proxy as TEvent);
+        this._setProperty(this._readModelProperty, handler.property);
+        return this._parent;
+    }
+
+    /** @inheritdoc */
+    toValue<TProperty>(value: TProperty): TParentBuilder {
+        this._setProperty(this._readModelProperty, JSON.stringify(value));
+        return this._parent;
+    }
+
+    /** @inheritdoc */
+    toEventContextProperty(contextPropertyName: string): TParentBuilder {
+        this._setProperty(this._readModelProperty, `$context.${contextPropertyName}`);
+        return this._parent;
+    }
+
+    /** @inheritdoc */
+    toEventSourceId(): TParentBuilder {
+        this._setProperty(this._readModelProperty, '$eventSourceId');
+        return this._parent;
+    }
+}

package/Projections/declarative/index.ts

@@ -0,0 +1,26 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export { projection, getProjectionMetadata, isProjection } from './projection';
+export type { ProjectionMetadata } from './projection';
+export { ProjectionBuilderFor } from './ProjectionBuilderFor';
+export { FromBuilder } from './FromBuilder';
+export { SetBuilder } from './SetBuilder';
+export { RemovedWithBuilder } from './RemovedWithBuilder';
+export type { IProjectionFor } from './IProjectionFor';
+export type { IProjectionBuilderFor } from './IProjectionBuilderFor';
+export type { IProjectionBuilder } from './IProjectionBuilder';
+export type { IFromBuilder } from './IFromBuilder';
+export type { IJoinBuilder } from './IJoinBuilder';
+export type { IFromEveryBuilder } from './IFromEveryBuilder';
+export type { IReadModelPropertiesBuilder } from './IReadModelPropertiesBuilder';
+export type { ICompositeKeyBuilder } from './ICompositeKeyBuilder';
+export type { ISetBuilder } from './ISetBuilder';
+export type { IAllSetBuilder } from './IAllSetBuilder';
+export type { IAddBuilder } from './IAddBuilder';
+export type { ISubtractBuilder } from './ISubtractBuilder';
+export type { IAddChildBuilder } from './IAddChildBuilder';
+export type { IChildrenBuilder } from './IChildrenBuilder';
+export type { INestedBuilder } from './INestedBuilder';
+export type { IRemovedWithBuilder } from './IRemovedWithBuilder';
+export type { IRemovedWithJoinBuilder } from './IRemovedWithJoinBuilder';

package/Projections/declarative/projection.ts

@@ -0,0 +1,59 @@
+// 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 { Constructor } from '@cratis/fundamentals';
+import { ProjectionId } from '../ProjectionId';
+import { DecoratorType, TypeDiscoverer } from '../../types';
+
+/** Metadata key used to store declarative projection information on a class. */
+const PROJECTION_METADATA_KEY = 'chronicle:projection';
+
+/**
+ * Metadata stored on a declarative projection class.
+ */
+export interface ProjectionMetadata {
+    /** The unique identifier for the projection. */
+    readonly id: ProjectionId;
+
+    /** The optional explicit event sequence identifier. */
+    readonly eventSequenceId: string | undefined;
+}
+
+/**
+ * TypeScript decorator that marks a class as a declarative projection.
+ * @param id - The unique identifier for the projection. Defaults to the class name if omitted.
+ * @param eventSequenceId - Optional explicit event sequence identifier.
+ * @returns A class decorator.
+ */
+export function projection(id: string = '', eventSequenceId?: string): ClassDecorator {
+    return (target: object) => {
+        const constructor = target as Function;
+        const projectionId = new ProjectionId(id || constructor.name);
+        const metadata: ProjectionMetadata = { id: projectionId, eventSequenceId };
+        Reflect.defineMetadata(PROJECTION_METADATA_KEY, metadata, target);
+        TypeDiscoverer.default.register(
+            DecoratorType.Projection,
+            constructor as Constructor,
+            projectionId.value
+        );
+    };
+}
+
+/**
+ * Gets the {@link ProjectionMetadata} associated with a class decorated with {@link projection}.
+ * @param target - The class constructor to retrieve metadata for.
+ * @returns The associated metadata, or undefined if not decorated.
+ */
+export function getProjectionMetadata(target: Function): ProjectionMetadata | undefined {
+    return Reflect.getMetadata(PROJECTION_METADATA_KEY, target);
+}
+
+/**
+ * Checks whether a class has been decorated with {@link projection}.
+ * @param target - The class constructor to check.
+ * @returns True if the class has a projection decorator; false otherwise.
+ */
+export function isProjection(target: Function): boolean {
+    return Reflect.hasMetadata(PROJECTION_METADATA_KEY, target);
+}

package/Projections/index.ts

@@ -0,0 +1,8 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export { ProjectionId } from './ProjectionId';
+export type { IProjections } from './IProjections';
+export { Projections } from './Projections';
+export * from './declarative';
+export * from './modelBound';

package/Projections/modelBound/FromEventMetadata.ts

@@ -0,0 +1,10 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { FromEventOptions } from './FromEventOptions';
+
+/** Metadata stored by the fromEvent decorator on a class. */
+export interface FromEventMetadata extends FromEventOptions {
+    /** The event constructor associated with this annotation. */
+    readonly eventType: Function;
+}

package/Projections/modelBound/FromEventOptions.ts

@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/** Options for the fromEvent class decorator. */
+export interface FromEventOptions {
+    /** The event property name to use as the key to identify the read model instance. */
+    readonly key?: string;
+    /** The event property name to use as the parent key for child relationships. */
+    readonly parentKey?: string;
+    /** A constant string value to use as the key. All events will update the same instance. */
+    readonly constantKey?: string;
+}