@cratis/chronicle 3.1.0 → 4.0.0

package/projections/Projections.operationalSurface.spec.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 'reflect-metadata';
+import { describe, expect, it, vi } from 'vitest';
+import { IClientArtifactsProvider } from '../artifacts';
+import { ChronicleConnection } from '../connection';
+import { ObserverRunningState } from '../observation/ObserverRunningState';
+import { eventType } from '../events/eventTypeDecorator';
+import { readModel } from '../readModels/readModel';
+import { eventSequence } from './modelBound/eventSequence';
+import { fromEvent } from './modelBound/fromEvent';
+import { projection } from './declarative/projection';
+import type { IProjectionBuilderFor } from './declarative/IProjectionBuilderFor';
+import type { IProjectionFor } from './declarative/IProjectionFor';
+import { Projections } from './Projections';
+import { UnableToQueryProjection } from './UnableToQueryProjection';
+
+// 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 OpStateChanged {
+    value!: string;
+}
+eventType()(OpStateChanged);
+
+class OpSummary {
+    id!: string;
+    value!: string;
+}
+fromEvent(OpStateChanged)(OpSummary);
+eventSequence('custom-op-sequence')(OpSummary);
+readModel()(OpSummary);
+
+class UndiscoveredSummary {
+    id!: string;
+}
+readModel()(UndiscoveredSummary);
+
+class DeclarativeReadModel {
+    id!: string;
+}
+readModel()(DeclarativeReadModel);
+
+class DeclarativeSummaryProjection implements IProjectionFor<DeclarativeReadModel> {
+    // discover() never calls define() - only register() does - so a no-op body is sufficient here.
+    define(_builder: IProjectionBuilderFor<DeclarativeReadModel>): void {}
+}
+projection('DeclarativeSummary', DeclarativeReadModel)(DeclarativeSummaryProjection);
+
+function wireObserverInformation() {
+    return {
+        RunningState: 1, // Active
+        IsSubscribed: true,
+        NextEventSequenceNumber: 5n,
+        LastHandledEventSequenceNumber: 4n,
+        TailEventSequenceNumber: 4n
+    };
+}
+
+async function createDiscoveredProjections() {
+    const getObserverInformation = vi.fn().mockResolvedValue(wireObserverInformation());
+    const replay = vi.fn().mockResolvedValue({ JobId: '11111111-1111-1111-1111-111111111111' });
+    const getFailedPartitions = vi.fn().mockResolvedValue({ items: [] });
+    const preview = vi.fn().mockResolvedValue({ Value0: { ReadModelEntries: ['{"id":"1"}'] } });
+    const registerMock = vi.fn().mockResolvedValue(undefined);
+    const registerManyMock = vi.fn().mockResolvedValue(undefined);
+
+    const connection = {
+        observers: { getObserverInformation, replay },
+        failedPartitions: { getFailedPartitions },
+        projections: { register: registerMock, preview },
+        readModels: { registerMany: registerManyMock }
+    } as unknown as ChronicleConnection;
+
+    const clientArtifacts: IClientArtifactsProvider = {
+        eventTypes: [],
+        readModels: [OpSummary, UndiscoveredSummary, DeclarativeReadModel] as unknown as IClientArtifactsProvider['readModels'],
+        reactors: [],
+        reducers: [],
+        seeders: [],
+        constraints: [],
+        projections: [DeclarativeSummaryProjection] as unknown as IClientArtifactsProvider['projections'],
+        webhooks: [],
+        eventTypeMigrations: []
+    };
+
+    const projections = new Projections('test-store', 'test-namespace', connection, clientArtifacts, 'test-sink');
+    await projections.discover();
+
+    return { projections, getObserverInformation, replay, getFailedPartitions, preview };
+}
+
+describe('Projections operational surface', () => {
+    describe('when checking hasFor with a discovered projection identifier', () => {
+        it('should return true', async () => {
+            const { projections } = await createDiscoveredProjections();
+            expect(projections.hasFor('OpSummary')).toBe(true);
+        });
+    });
+
+    describe('when checking hasFor with an unknown projection identifier', () => {
+        it('should return false', async () => {
+            const { projections } = await createDiscoveredProjections();
+            expect(projections.hasFor('unknown-projection')).toBe(false);
+        });
+    });
+
+    describe('when checking hasForModel for a discovered model-bound read model', () => {
+        it('should return true', async () => {
+            const { projections } = await createDiscoveredProjections();
+            expect(projections.hasForModel(OpSummary)).toBe(true);
+        });
+    });
+
+    describe('when checking hasForModel for an undiscovered read model', () => {
+        it('should return false', async () => {
+            const { projections } = await createDiscoveredProjections();
+            expect(projections.hasForModel(UndiscoveredSummary)).toBe(false);
+        });
+    });
+
+    describe('when getting the projection identifier for a model-bound read model', () => {
+        it('should resolve the read model identifier', async () => {
+            const { projections } = await createDiscoveredProjections();
+            expect(projections.getProjectionIdFor(OpSummary).value).toBe('OpSummary');
+        });
+    });
+
+    describe('when getting the projection identifier for a declarative projection with an explicit read model type', () => {
+        it('should resolve the declared projection identifier', async () => {
+            const { projections } = await createDiscoveredProjections();
+            expect(projections.getProjectionIdFor(DeclarativeReadModel).value).toBe('DeclarativeSummary');
+        });
+    });
+
+    describe('when getting the projection identifier for an undiscovered read model', () => {
+        it('should throw', async () => {
+            const { projections } = await createDiscoveredProjections();
+            expect(() => projections.getProjectionIdFor(UndiscoveredSummary)).toThrow();
+        });
+    });
+
+    describe('when getting state for a projection by identifier', () => {
+        it('should call GetObserverInformation and map the response', async () => {
+            const { projections, getObserverInformation } = await createDiscoveredProjections();
+
+            const state = await projections.getStateFor('OpSummary');
+
+            expect(getObserverInformation).toHaveBeenCalledTimes(1);
+            const request = getObserverInformation.mock.calls[0][0];
+            expect(request.EventStore).toEqual('test-store');
+            expect(request.Namespace).toEqual('test-namespace');
+            expect(request.ObserverId).toEqual('OpSummary');
+
+            expect(state.runningState).toBe(ObserverRunningState.Active);
+            expect(state.isSubscribed).toBe(true);
+            expect(state.nextEventSequenceNumber.value).toEqual(5n);
+            expect(state.lastHandledEventSequenceNumber.value).toEqual(4n);
+            expect(state.tailEventSequenceNumber.value).toEqual(4n);
+        });
+    });
+
+    describe('when getting state for a model-bound read model with a custom event sequence', () => {
+        it('should resolve the identifier and pass the model-declared event sequence', async () => {
+            const { projections, getObserverInformation } = await createDiscoveredProjections();
+
+            await projections.getStateForModel(OpSummary);
+
+            const request = getObserverInformation.mock.calls[0][0];
+            expect(request.ObserverId).toEqual('OpSummary');
+            expect(request.EventSequenceId).toEqual('custom-op-sequence');
+        });
+    });
+
+    describe('when getting failed partitions for a model-bound read model', () => {
+        it('should call GetFailedPartitions with the resolved projection identifier', async () => {
+            const { projections, getFailedPartitions } = await createDiscoveredProjections();
+
+            await projections.getFailedPartitionsForModel(OpSummary);
+
+            expect(getFailedPartitions).toHaveBeenCalledTimes(1);
+            const request = getFailedPartitions.mock.calls[0][0];
+            expect(request.ObserverId).toEqual('OpSummary');
+        });
+    });
+
+    describe('when replaying a projection by identifier', () => {
+        it('should call Replay and parse the returned job id', async () => {
+            const { projections, replay } = await createDiscoveredProjections();
+
+            const jobId = await projections.replay('OpSummary');
+
+            expect(replay).toHaveBeenCalledTimes(1);
+            const request = replay.mock.calls[0][0];
+            expect(request.ObserverId).toEqual('OpSummary');
+            expect(jobId.toString()).toEqual('11111111-1111-1111-1111-111111111111');
+        });
+    });
+
+    describe('when replaying a projection that is not replayable', () => {
+        it('should resolve to a not-set job id', async () => {
+            const { projections, replay } = await createDiscoveredProjections();
+            replay.mockResolvedValueOnce({ JobId: '' });
+
+            const jobId = await projections.replay('OpSummary');
+
+            expect(jobId.value.toString()).toEqual('00000000-0000-0000-0000-000000000000');
+        });
+    });
+
+    describe('when replaying a model-bound read model', () => {
+        it('should resolve the identifier and replay it', async () => {
+            const { projections, replay } = await createDiscoveredProjections();
+
+            await projections.replayForModel(OpSummary);
+
+            const request = replay.mock.calls[0][0];
+            expect(request.ObserverId).toEqual('OpSummary');
+        });
+    });
+
+    describe('when querying a projection declaration', () => {
+        it('should call Preview and return the read model entries', async () => {
+            const { projections, preview } = await createDiscoveredProjections();
+
+            const result = await projections.query('projection Orders\n  from OpStateChanged');
+
+            expect(preview).toHaveBeenCalledTimes(1);
+            const request = preview.mock.calls[0][0];
+            expect(request.EventSequenceId).toEqual('event-log');
+            expect(result.readModelEntries).toEqual(['{"id":"1"}']);
+        });
+    });
+
+    describe('when querying a projection declaration with a custom event sequence', () => {
+        it('should pass the given event sequence identifier', async () => {
+            const { projections, preview } = await createDiscoveredProjections();
+
+            await projections.query('projection Orders\n  from OpStateChanged', 'inbox');
+
+            const request = preview.mock.calls[0][0];
+            expect(request.EventSequenceId).toEqual('inbox');
+        });
+    });
+
+    describe('when querying a projection declaration that fails to parse', () => {
+        it('should throw UnableToQueryProjection with the syntax errors', async () => {
+            const { projections, preview } = await createDiscoveredProjections();
+            preview.mockResolvedValueOnce({
+                Value1: { Errors: [{ Message: 'Unexpected token', Line: 2, Column: 3 }] }
+            });
+
+            await expect(projections.query('projection Bad')).rejects.toThrow(UnableToQueryProjection);
+        });
+    });
+});

package/projections/Projections.spec.ts

@@ -85,7 +85,7 @@ function createProjections(readModels: (new (...args: unknown[]) => unknown)[])
         eventTypeMigrations: []
     };
 
-    const projections = new Projections('test-store', connection, clientArtifacts, 'test-sink');
+    const projections = new Projections('test-store', 'test-namespace', connection, clientArtifacts, 'test-sink');
     return { projections, registerMock };
 }
 

package/projections/Projections.ts

@@ -12,6 +12,11 @@ import { ChronicleConnection } from '../connection';
 import { toContractsGuid } from '../connection/Guid';
 import { WellKnownSinks } from '../sinks';
 import { EventSequenceId } from '../eventSequences/EventSequenceId';
+import { EventSequenceNumber } from '../eventSequences/EventSequenceNumber';
+import { JobId } from '../jobs/JobId';
+import { FailedPartition } from '../observation/FailedPartition';
+import { FailedPartitions } from '../observation/FailedPartitions';
+import { toObserverRunningState } from '../observation/toObserverRunningState';
 import { getReadModelMetadata } from '../readModels';
 import { TypeIntrospector } from '../types';
 import { IProjections } from './IProjections';
@@ -24,20 +29,28 @@ import {
     buildNestedEntry,
     ChildrenDefinitionLike,
     ContractEventType,
+    ensureFromEntry,
     FromRecord,
     getEventTypeMapKey,
     toContractEventType
 } from './modelBound/childrenAndNestedBuilder';
 import { getChildrenFromMetadata } from './modelBound/childrenFrom';
+import { getClearWithPropertyMetadata } from './modelBound/clearWith';
+import { getEventSequenceMetadata } from './modelBound/eventSequence';
+import { getFromAllMetadata } from './modelBound/fromAll';
 import { getFromEveryMetadata } from './modelBound/fromEvery';
 import { getFromEventMetadata, hasFromEventMetadata } from './modelBound/fromEvent';
 import { getJoinMetadata } from './modelBound/join';
+import { isNoAutoMap, isPropertyNoAutoMap } from './modelBound/noAutoMap';
 import { ProjectionId } from './ProjectionId';
+import { ProjectionQueryResult } from './ProjectionQueryResult';
+import { ProjectionState } from './ProjectionState';
 import { isNested } from './modelBound/nested';
 import { isNotRewindable } from './modelBound/notRewindable';
 import { isPassive } from './modelBound/passive';
 import { getRemovedWithClassMetadata, getRemovedWithPropertyMetadata } from './modelBound/removedWith';
 import { getRemovedWithJoinClassMetadata, getRemovedWithJoinPropertyMetadata } from './modelBound/removedWithJoin';
+import { UnableToQueryProjection } from './UnableToQueryProjection';
 
 interface ResolvedModelBoundMetadata {
     id: ProjectionId;
@@ -52,19 +65,27 @@ interface ResolvedModelBoundMetadata {
 export class Projections implements IProjections {
     private readonly _declarative = new Map<string, Constructor>();
     private readonly _modelBound = new Map<string, Constructor>();
+    private readonly _failedPartitions: FailedPartitions;
 
     private readonly _logger = diag.createComponentLogger({ namespace: '@cratis/chronicle/projections' });
 
     /**
      * Creates a new {@link Projections} instance.
+     * @param _eventStore - The event store name.
+     * @param _namespace - The event store namespace.
+     * @param _connection - Chronicle connection.
      * @param _clientArtifacts - Provider for discovered client artifact types.
+     * @param _defaultSinkTypeId - The identifier of the default read model sink.
      */
     constructor(
         private readonly _eventStore: string,
+        private readonly _namespace: string,
         private readonly _connection: ChronicleConnection,
         private readonly _clientArtifacts: IClientArtifactsProvider,
         private readonly _defaultSinkTypeId: string
-    ) {}
+    ) {
+        this._failedPartitions = new FailedPartitions(_eventStore, _namespace, _connection);
+    }
 
     /** @inheritdoc */
     async discover(): Promise<void> {
@@ -137,6 +158,148 @@ export class Projections implements IProjections {
         }
     }
 
+    /** @inheritdoc */
+    hasFor(projectionId: ProjectionId | string): boolean {
+        const id = this.toProjectionIdValue(projectionId);
+        return this._declarative.has(id) || this._modelBound.has(id);
+    }
+
+    /** @inheritdoc */
+    hasForModel(readModelType: Constructor): boolean {
+        try {
+            this.resolveProjectionIdForModel(readModelType);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    /** @inheritdoc */
+    getProjectionIdFor(readModelType: Constructor): ProjectionId {
+        return this.resolveProjectionIdForModel(readModelType);
+    }
+
+    /** @inheritdoc */
+    async getStateFor(projectionId: ProjectionId | string): Promise<ProjectionState> {
+        const id = this.toProjectionIdValue(projectionId);
+        const eventSequenceId = this.resolveEventSequenceIdFor(id);
+
+        const response = await this._connection.observers.getObserverInformation({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            ObserverId: id,
+            EventSequenceId: eventSequenceId
+        });
+
+        return {
+            runningState: toObserverRunningState(response.RunningState),
+            isSubscribed: response.IsSubscribed,
+            nextEventSequenceNumber: new EventSequenceNumber(response.NextEventSequenceNumber),
+            lastHandledEventSequenceNumber: new EventSequenceNumber(response.LastHandledEventSequenceNumber),
+            tailEventSequenceNumber: new EventSequenceNumber(response.TailEventSequenceNumber)
+        };
+    }
+
+    /** @inheritdoc */
+    getStateForModel(readModelType: Constructor): Promise<ProjectionState> {
+        return this.getStateFor(this.resolveProjectionIdForModel(readModelType));
+    }
+
+    /** @inheritdoc */
+    getFailedPartitionsForModel(readModelType: Constructor): Promise<FailedPartition[]> {
+        const projectionId = this.resolveProjectionIdForModel(readModelType);
+        return this._failedPartitions.getFailedPartitionsFor(projectionId.value);
+    }
+
+    /** @inheritdoc */
+    async replay(projectionId: ProjectionId | string): Promise<JobId> {
+        const id = this.toProjectionIdValue(projectionId);
+
+        const response = await this._connection.observers.replay({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            ObserverId: id,
+
+            // The kernel resolves the observer's own event sequence from its identifier - it does not
+            // need to be told which one to replay.
+            EventSequenceId: ''
+        });
+
+        return response.JobId ? JobId.from(response.JobId) : JobId.from(Guid.empty);
+    }
+
+    /** @inheritdoc */
+    replayForModel(readModelType: Constructor): Promise<JobId> {
+        return this.replay(this.resolveProjectionIdForModel(readModelType));
+    }
+
+    /** @inheritdoc */
+    async query(declaration: string, eventSequenceId: string = EventSequenceId.eventLog.value): Promise<ProjectionQueryResult> {
+        const result = await this._connection.projections.preview({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            EventSequenceId: eventSequenceId,
+            Declaration: declaration
+        });
+
+        if (result.Value1) {
+            throw new UnableToQueryProjection(result.Value1.Errors.map(error => error.Message));
+        }
+
+        return {
+            readModelEntries: result.Value0?.ReadModelEntries ?? []
+        };
+    }
+
+    private toProjectionIdValue(projectionId: ProjectionId | string): string {
+        return typeof projectionId === 'string' ? projectionId : projectionId.value;
+    }
+
+    /**
+     * Resolves the {@link ProjectionId} of the projection that maintains a specific read model type,
+     * from what has already been discovered.
+     * @param readModelType - The read model type to resolve for.
+     * @returns The resolved {@link ProjectionId}.
+     */
+    private resolveProjectionIdForModel(readModelType: Constructor): ProjectionId {
+        for (const [id, type] of this._modelBound) {
+            if (type === readModelType) {
+                return new ProjectionId(id);
+            }
+        }
+
+        for (const [id, type] of this._declarative) {
+            const metadata = getProjectionMetadata(type);
+            if (metadata?.readModelType === readModelType) {
+                return new ProjectionId(id);
+            }
+        }
+
+        throw new Error(
+            `No projection found for read model '${readModelType.name}'. Make sure discover() has run and the ` +
+            'read model is model-bound, or its declarative projection() decorator specifies an explicit readModelType.');
+    }
+
+    /**
+     * Resolves the event sequence identifier a discovered projection reads from, without requiring
+     * its full definition to have been built.
+     * @param projectionId - The projection identifier to resolve for.
+     * @returns The resolved event sequence identifier.
+     */
+    private resolveEventSequenceIdFor(projectionId: string): string {
+        const modelBoundType = this._modelBound.get(projectionId);
+        if (modelBoundType) {
+            return getEventSequenceMetadata(modelBoundType) ?? EventSequenceId.eventLog.value;
+        }
+
+        const declarativeType = this._declarative.get(projectionId);
+        if (declarativeType) {
+            return getProjectionMetadata(declarativeType)?.eventSequenceId ?? EventSequenceId.eventLog.value;
+        }
+
+        return EventSequenceId.eventLog.value;
+    }
+
     private async registerWithRetry(projection: unknown, identifier: string, maxAttempts = 5): Promise<void> {
         let delay = 2000;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -344,14 +507,25 @@ export class Projections implements IProjections {
                 childrenByProperty[property] = buildChildrenEntry(type, property, childrenFromList);
             }
 
-            if (isNested(prototype, property)) {
+            const propertyIsNested = isNested(prototype, property);
+            if (propertyIsNested) {
                 nestedByProperty[property] = buildNestedEntry(type, property);
             }
+
+            // A scalar (non-nested, non-children-collection) root property clears back to no value
+            // every time the given event is observed. A nested single-object property's clearWith is
+            // handled by buildNestedEntry instead, which clears the whole nested object.
+            if (childrenFromList.length === 0 && !propertyIsNested) {
+                for (const clearWith of getClearWithPropertyMetadata(prototype, property)) {
+                    const entry = ensureFromEntry(fromByEventType, clearWith.eventType);
+                    entry.Value.Properties[property] = '$null';
+                }
+            }
         }
 
         const allProperties: Record<string, string> = {};
         for (const property of properties) {
-            const fromEvery = getFromEveryMetadata(prototype, property);
+            const fromEvery = getFromEveryMetadata(prototype, property) ?? getFromAllMetadata(prototype, property);
             if (fromEvery) {
                 allProperties[property] = fromEvery.contextProperty
                     ? fromEvery.contextProperty
@@ -379,7 +553,8 @@ export class Projections implements IProjections {
             RemovedWithJoin: Array.from(removedWithJoinByEventType.values()),
             LastUpdated: { Value: '' },
             Tags: [],
-            AutoMap: AutoMap.Enabled,
+            AutoMap: isNoAutoMap(type) ? AutoMap.Disabled : AutoMap.Enabled,
+            NoAutoMapProperties: properties.filter(property => isPropertyNoAutoMap(prototype, property)),
             Nested: nestedByProperty
         };
         definition.LastUpdated = { Value: this.computeStableLastUpdated(definition) };
@@ -392,7 +567,7 @@ export class Projections implements IProjections {
         if (readModelMetadata && hasFromEventMetadata(type)) {
             return {
                 id: new ProjectionId(readModelMetadata.id.value),
-                eventSequenceId: undefined,
+                eventSequenceId: getEventSequenceMetadata(type),
                 readModelIdentifier: readModelMetadata.id.value
             };
         }

package/projections/UnableToQueryProjection.ts

@@ -0,0 +1,17 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Error thrown when a projection query fails because the Projection Declaration Language
+ * declaration contains errors.
+ */
+export class UnableToQueryProjection extends Error {
+    /**
+     * Creates a new {@link UnableToQueryProjection}.
+     * @param errors - The collection of error messages describing why the query failed.
+     */
+    constructor(errors: ReadonlyArray<string>) {
+        super(`Unable to query projection. Errors:\n${errors.join('\n')}`);
+        this.name = 'UnableToQueryProjection';
+    }
+}

package/projections/index.ts

@@ -4,5 +4,8 @@
 export { ProjectionId } from './ProjectionId';
 export type { IProjections } from './IProjections';
 export { Projections } from './Projections';
+export type { ProjectionState } from './ProjectionState';
+export type { ProjectionQueryResult } from './ProjectionQueryResult';
+export { UnableToQueryProjection } from './UnableToQueryProjection';
 export * from './declarative';
 export * from './modelBound';

package/projections/modelBound/eventSequence.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 'reflect-metadata';
+import { EventSequenceId } from '../../eventSequences/EventSequenceId';
+
+const METADATA_KEY = 'chronicle:projection:eventSequence';
+
+/**
+ * Class decorator that overrides the event sequence a model-bound projection reads from.
+ * When applied, auto-inbox routing is suppressed - the explicit value is always honored.
+ * @param sequence - The event sequence identifier to read from.
+ * @returns A class decorator.
+ */
+export function eventSequence(sequence: string): ClassDecorator {
+    return (target: object) => {
+        Reflect.defineMetadata(METADATA_KEY, sequence, target);
+    };
+}
+
+/**
+ * Convenience class decorator that pins a model-bound projection to the default event log
+ * sequence. Equivalent to `eventSequence(EventSequenceId.eventLog.value)`, but more expressive
+ * about the intent to read from the local event log rather than an inbox or another sequence.
+ * @param target - The class constructor.
+ */
+export function eventLog(target: Function): void {
+    Reflect.defineMetadata(METADATA_KEY, EventSequenceId.eventLog.value, target);
+}
+
+/**
+ * Retrieves the explicit event sequence identifier stored on a class, if any.
+ * @param target - The class constructor.
+ * @returns The event sequence identifier, or undefined when the class has no explicit override.
+ */
+export function getEventSequenceMetadata(target: Function): string | undefined {
+    return Reflect.getMetadata(METADATA_KEY, target);
+}

package/projections/modelBound/fromAll.ts

@@ -0,0 +1,42 @@
+// 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 { TypeIntrospector } from '../../types';
+
+/** Metadata stored by the fromAll property decorator. */
+export interface FromAllMetadata {
+    /** The event property name to read the value from. */
+    readonly property?: string;
+    /** The event context property name to read the value from. */
+    readonly contextProperty?: string;
+}
+
+const METADATA_KEY = 'chronicle:projection:fromAll';
+
+/**
+ * Property decorator that sets the decorated read model property from a property present on every
+ * event type the projection is built from - the convention-based counterpart to declaring the same
+ * mapping on every individual `fromEvent`. Equivalent to {@link fromEvery} for model-bound
+ * projections; use whichever name reads better for the property being mapped.
+ * @param property - Optional event property name. If not specified, uses the model property name.
+ * @param contextProperty - Optional event context property name.
+ * @returns A property decorator.
+ */
+export function fromAll(property?: string, contextProperty?: string): PropertyDecorator {
+    return (target: object, propertyKey: string | symbol) => {
+        TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, propertyKey.toString());
+        const metadata: FromAllMetadata = { property, contextProperty };
+        Reflect.defineMetadata(METADATA_KEY, metadata, target, propertyKey.toString());
+    };
+}
+
+/**
+ * Retrieves fromAll metadata stored on the given property.
+ * @param target - The class prototype.
+ * @param propertyKey - The property name.
+ * @returns The fromAll metadata, or undefined if not decorated.
+ */
+export function getFromAllMetadata(target: object, propertyKey: string): FromAllMetadata | undefined {
+    return Reflect.getMetadata(METADATA_KEY, target, propertyKey);
+}

package/projections/modelBound/index.ts

@@ -35,3 +35,7 @@ export { setValue, getSetValueMetadata } from './setValue';
 export type { SetValueMetadata } from './setValue';
 export { fromEvery, getFromEveryMetadata } from './fromEvery';
 export type { FromEveryMetadata } from './fromEvery';
+export { fromAll, getFromAllMetadata } from './fromAll';
+export type { FromAllMetadata } from './fromAll';
+export { noAutoMap, isNoAutoMap, isPropertyNoAutoMap } from './noAutoMap';
+export { eventSequence, eventLog, getEventSequenceMetadata } from './eventSequence';