@cratis/chronicle 0.0.1 → 0.2.0

package/Projections/declarative/ProjectionBuilderFor.ts

@@ -1,277 +0,0 @@
-// 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/projection.ts

@@ -1,59 +0,0 @@
-// 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/modelBound/index.ts

@@ -1,38 +0,0 @@
-// Copyright (c) Cratis. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-export { modelBound, getModelBoundMetadata, isModelBound } from './modelBound';
-export type { ModelBoundMetadata } from './modelBound';
-export { fromEvent, getFromEventMetadata, hasFromEventMetadata } from './fromEvent';
-export type { FromEventOptions } from './FromEventOptions';
-export type { FromEventMetadata } from './FromEventMetadata';
-export { setFrom, getSetFromMetadata } from './setFrom';
-export type { SetFromMetadata } from './setFrom';
-export { setFromContext, getSetFromContextMetadata } from './setFromContext';
-export type { SetFromContextMetadata } from './setFromContext';
-export { join, getJoinMetadata } from './join';
-export type { JoinMetadata } from './join';
-export { addFrom, getAddFromMetadata } from './addFrom';
-export type { AddFromMetadata } from './addFrom';
-export { subtractFrom, getSubtractFromMetadata } from './subtractFrom';
-export type { SubtractFromMetadata } from './subtractFrom';
-export { increment, getIncrementMetadata } from './increment';
-export type { IncrementMetadata } from './increment';
-export { decrement, getDecrementMetadata } from './decrement';
-export type { DecrementMetadata } from './decrement';
-export { count, getCountMetadata } from './count';
-export type { CountMetadata } from './count';
-export { childrenFrom, getChildrenFromMetadata } from './childrenFrom';
-export type { ChildrenFromMetadata } from './childrenFrom';
-export { nested, isNested } from './nested';
-export { clearWith, getClearWithClassMetadata, getClearWithPropertyMetadata } from './clearWith';
-export type { ClearWithMetadata } from './clearWith';
-export { removedWith, getRemovedWithClassMetadata, getRemovedWithPropertyMetadata } from './removedWith';
-export type { RemovedWithMetadata } from './removedWith';
-export { removedWithJoin, getRemovedWithJoinClassMetadata, getRemovedWithJoinPropertyMetadata } from './removedWithJoin';
-export type { RemovedWithJoinMetadata } from './removedWithJoin';
-export { notRewindable, isNotRewindable } from './notRewindable';
-export { setValue, getSetValueMetadata } from './setValue';
-export type { SetValueMetadata } from './setValue';
-export { fromEvery, getFromEveryMetadata } from './fromEvery';
-export type { FromEveryMetadata } from './fromEvery';

package/Projections/modelBound/modelBound.ts

@@ -1,59 +0,0 @@
-// 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 model-bound projection information on a class. */
-const MODEL_BOUND_METADATA_KEY = 'chronicle:modelBound';
-
-/**
- * Metadata stored on a model-bound projection class.
- */
-export interface ModelBoundMetadata {
-    /** 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 model-bound 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 modelBound(id: string = '', eventSequenceId?: string): ClassDecorator {
-    return (target: object) => {
-        const constructor = target as Function;
-        const projectionId = new ProjectionId(id || constructor.name);
-        const metadata: ModelBoundMetadata = { id: projectionId, eventSequenceId };
-        Reflect.defineMetadata(MODEL_BOUND_METADATA_KEY, metadata, target);
-        TypeDiscoverer.default.register(
-            DecoratorType.ModelBoundProjection,
-            constructor as Constructor,
-            projectionId.value
-        );
-    };
-}
-
-/**
- * Gets the {@link ModelBoundMetadata} associated with a class decorated with {@link modelBound}.
- * @param target - The class constructor to retrieve metadata for.
- * @returns The associated metadata, or undefined if not decorated.
- */
-export function getModelBoundMetadata(target: Function): ModelBoundMetadata | undefined {
-    return Reflect.getMetadata(MODEL_BOUND_METADATA_KEY, target);
-}
-
-/**
- * Checks whether a class has been decorated with {@link modelBound}.
- * @param target - The class constructor to check.
- * @returns True if the class has a model-bound decorator; false otherwise.
- */
-export function isModelBound(target: Function): boolean {
-    return Reflect.hasMetadata(MODEL_BOUND_METADATA_KEY, target);
-}

package/Projections/modelBound/setFromContext.ts

@@ -1,41 +0,0 @@
-// 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 setFromContext property decorator. */
-export interface SetFromContextMetadata {
-    /** The event constructor associated with this annotation. */
-    readonly eventType: Function;
-    /** The event context property name to read the value from. Defaults to the decorated property name. */
-    readonly contextPropertyName?: string;
-}
-
-const METADATA_KEY = 'chronicle:projection:setFromContext';
-
-/**
- * Property decorator that maps a value from an event context property onto the decorated read model property.
- * @param eventType - The event constructor.
- * @param contextPropertyName - Optional event context property name. Defaults to the property name.
- * @returns A property decorator.
- */
-export function setFromContext(eventType: Function, contextPropertyName?: string): PropertyDecorator {
-    return (target: object, propertyKey: string | symbol) => {
-        const key = propertyKey.toString();
-        TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, key);
-        const existing: SetFromContextMetadata[] = Reflect.getMetadata(METADATA_KEY, target, key) ?? [];
-        const metadata: SetFromContextMetadata = { eventType, contextPropertyName };
-        Reflect.defineMetadata(METADATA_KEY, [...existing, metadata], target, key);
-    };
-}
-
-/**
- * Retrieves all setFromContext metadata stored on the given property.
- * @param target - The class prototype.
- * @param propertyKey - The property name.
- * @returns An array of setFromContext metadata entries.
- */
-export function getSetFromContextMetadata(target: object, propertyKey: string): SetFromContextMetadata[] {
-    return Reflect.getMetadata(METADATA_KEY, target, propertyKey) ?? [];
-}