@cratis/chronicle 6.7.1 → 6.8.0

package/events/classDecorators.standard.spec.ts

@@ -1,8 +1,14 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
+import { DefaultClientArtifactsProvider } from '../artifacts/DefaultClientArtifactsProvider.js';
+import type { IClientArtifactsProvider } from '../artifacts/IClientArtifactsProvider.js';
+import type { ChronicleConnection } from '../connection/ChronicleConnection.js';
+import { Constraints } from './constraints/Constraints.js';
 import { constraint, getConstraintMetadata } from './constraints/constraint.js';
+import { unique, getUniqueEventMetadata, getUniquePropertyMetadata } from './constraints/unique.js';
+import { removeConstraint, getRemovedConstraintNames } from './constraints/removeConstraint.js';
 import { eventType, getEventTypeMetadata } from './eventTypeDecorator.js';
 import { filterEventsByTag, getFilterTagsFor } from './filterEventsByTagDecorator.js';
 import { eventTypeMigration, getEventTypeMigrationMetadata } from './migrations/eventTypeMigration.js';
@@ -29,6 +35,20 @@ class Migration {}
 @constraint('standard-constraint')
 class Constraint {}
 
+@eventType('standard-unique-property')
+class UniquePropertyEvent {
+    @unique('standard-unique-name', 'Already taken') name = '';
+}
+
+@eventType('standard-unique-class')
+@unique('standard-unique-type', 'Already registered')
+class UniqueEvent {}
+
+@eventType('standard-unique-release')
+@removeConstraint('standard-unique-name')
+@removeConstraint('standard-unique-type')
+class UniqueRelease {}
+
 @tag('first')
 @tags('second')
 @filterEventsByTag('required')
@@ -61,6 +81,9 @@ describe('standard class decorators', () => {
         expect(getEventTypeMetadata(Previous)?.schema.properties).toEqual({});
         expect(getEventTypeMigrationMetadata(Migration)?.eventType.generation.value).toBe(2);
         expect(getConstraintMetadata(Constraint)?.id.value).toBe('standard-constraint');
+        expect(getUniquePropertyMetadata(UniquePropertyEvent, 'name')).toEqual({ name: 'standard-unique-name', message: 'Already taken' });
+        expect(getUniqueEventMetadata(UniqueEvent)).toEqual({ name: 'standard-unique-type', message: 'Already registered' });
+        expect(getRemovedConstraintNames(UniqueRelease)).toEqual(['standard-unique-type', 'standard-unique-name']);
         expect(getTagsFor(Tagged).map(item => item.value)).toEqual(['second', 'first']);
         expect(getFilterTagsFor(Tagged).map(item => item.value)).toEqual(['required']);
         expect(getFromEventMetadata(ModelBound)).toHaveLength(1);
@@ -74,4 +97,25 @@ describe('standard class decorators', () => {
         expect(getSeederMetadata(Seeder)?.isSeeder).toBe(true);
         expect(getWebhookMetadata(Webhook)?.targetUrl.value).toBe('https://example.com/hooks');
     });
+
+    it('registers standard-decorated constraints through normal artifact discovery', async () => {
+        const register = vi.fn().mockResolvedValue({});
+        const connection = { constraints: { register } } as unknown as ChronicleConnection;
+        const artifacts = {
+            eventTypes: DefaultClientArtifactsProvider.default.eventTypes.filter(type =>
+                [UniquePropertyEvent, UniqueEvent, UniqueRelease].includes(type)),
+            constraints: []
+        } as unknown as IClientArtifactsProvider;
+        const constraints = new Constraints('store', connection, artifacts);
+        await constraints.register();
+        const definitions = register.mock.calls[0][0].Constraints;
+        const property = definitions.find((definition: { Name: string }) => definition.Name === 'standard-unique-name');
+        const eventType = definitions.find((definition: { Name: string }) => definition.Name === 'standard-unique-type');
+        expect(property.Definition.Value0.EventDefinitions).toEqual([
+            { EventTypeId: 'standard-unique-property', Properties: ['name'] }
+        ]);
+        expect(property.RemovedWith).toEqual(['standard-unique-release']);
+        expect(eventType.Definition.Value1.EventTypeIds).toEqual(['standard-unique-class']);
+        expect(eventType.RemovedWith).toEqual(['standard-unique-release']);
+    });
 });

package/events/constraints/ConstraintBuilder.ts

@@ -16,6 +16,8 @@ export interface ConstraintScopeCapture {
 /** Represents the captured definition of a unique event type constraint. */
 export interface UniqueEventTypeCapture {
     eventTypeId: string;
+    eventTypeIds?: string[];
+    removedWithEventTypeIds?: string[];
     message?: string;
     name?: string;
 }

package/events/constraints/Constraints.ts

@@ -2,17 +2,40 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { ConstraintType } from '@cratis/chronicle.contracts';
+import type { ConstraintViolation } from '../../eventSequences/ConstraintViolation.js';
 import { IClientArtifactsProvider } from '../../artifacts/index.js';
 import { ChronicleConnection } from '../../connection/index.js';
 import { ConstraintId } from './ConstraintId.js';
 import { IConstraint } from './IConstraint.js';
 import { IConstraints } from './IConstraints.js';
-import { ConstraintBuilder, ConstraintCapture } from './ConstraintBuilder.js';
+import { ConstraintBuilder, ConstraintCapture, ConstraintScopeCapture } from './ConstraintBuilder.js';
+import { UniqueConstraintBuilder } from './UniqueConstraintBuilder.js';
 import { getConstraintMetadata } from './constraint.js';
+import { getUniqueEventMetadata, getUniquePropertyMetadata } from './unique.js';
+import { getRemovedConstraintNames } from './removeConstraint.js';
+import { TypeIntrospector } from '../../types/TypeIntrospector.js';
+import { getEventTypeFor } from '../eventTypeDecorator.js';
 
-/**
- * Manages discovery and registration of constraints with the Chronicle Kernel.
- */
+/** Resolves the name registered with the Chronicle Kernel. */
+function wireNameOf(capture: ConstraintCapture): string {
+    return capture.uniqueEventType?.name ?? capture.name;
+}
+
+const decoratorScope: ConstraintScopeCapture = {
+    perEventSourceType: false,
+    perEventStreamType: false,
+    perEventStreamId: false
+};
+
+function assertMatchingScope(name: string, left: ConstraintScopeCapture, right: ConstraintScopeCapture): void {
+    if (left.perEventSourceType !== right.perEventSourceType ||
+        left.perEventStreamType !== right.perEventStreamType ||
+        left.perEventStreamId !== right.perEventStreamId) {
+        throw new Error(`Conflicting scopes for constraint '${name}'.`);
+    }
+}
+
+/** Manages discovery and registration of constraints with the Chronicle Kernel. */
 export class Constraints implements IConstraints {
     private readonly _captures = new Map<string, ConstraintCapture>();
 
@@ -31,14 +54,107 @@ export class Constraints implements IConstraints {
     /** @inheritdoc */
     async discover(): Promise<void> {
         this._captures.clear();
+        const fluentIds = new Set<string>();
         for (const type of this._clientArtifacts.constraints) {
             const metadata = getConstraintMetadata(type);
             if (!metadata) continue;
+            if (fluentIds.has(metadata.id.value)) throw new Error(`Duplicate constraint id '${metadata.id.value}'.`);
+            fluentIds.add(metadata.id.value);
 
             const builder = new ConstraintBuilder(metadata.id.value);
             const instance = new (type as new () => IConstraint)();
             instance.define(builder);
-            this._captures.set(metadata.id.value, builder.capture);
+            const capture = builder.capture;
+            const name = wireNameOf(capture);
+            const existing = this._captures.get(name);
+            if (existing?.uniqueEventType && capture.uniqueEventType) {
+                assertMatchingScope(name, existing.scope, capture.scope);
+                const merged = existing.uniqueEventType;
+                if (capture.uniqueEventType.message && !merged.message) merged.message = capture.uniqueEventType.message;
+                const ids = merged.eventTypeIds ??= [merged.eventTypeId];
+                for (const id of capture.uniqueEventType.eventTypeIds ?? [capture.uniqueEventType.eventTypeId]) {
+                    if (!ids.includes(id)) ids.push(id);
+                }
+                const removedWith = merged.removedWithEventTypeIds ??= [];
+                for (const id of capture.uniqueEventType.removedWithEventTypeIds ?? []) {
+                    if (!removedWith.includes(id)) removedWith.push(id);
+                }
+            } else if (existing) {
+                throw new Error(`Duplicate constraint name '${name}'.`);
+            } else {
+                this._captures.set(name, capture);
+            }
+        }
+
+        const removalEvents = new Map<string, Function[]>();
+        for (const eventType of this._clientArtifacts.eventTypes) {
+            for (const name of getRemovedConstraintNames(eventType)) {
+                const events = removalEvents.get(name) ?? [];
+                events.push(eventType);
+                removalEvents.set(name, events);
+            }
+        }
+
+        for (const eventType of this._clientArtifacts.eventTypes) {
+            const eventMetadata = getUniqueEventMetadata(eventType);
+            if (eventMetadata) {
+                const name = eventMetadata.name ?? eventType.name;
+                let capture = this._captures.get(name);
+                if (!capture) {
+                    const builder = new ConstraintBuilder(name);
+                    builder.uniqueFor(eventType, eventMetadata.message, name);
+                    capture = builder.capture;
+                    this._captures.set(name, capture);
+                } else if (!capture.uniqueEventType) {
+                    throw new Error(`Constraint '${name}' is not a unique event type constraint.`);
+                } else {
+                    assertMatchingScope(name, capture.scope, decoratorScope);
+                    if (eventMetadata.message && !capture.uniqueEventType.message) capture.uniqueEventType.message = eventMetadata.message;
+                    capture.uniqueEventType.eventTypeIds ??= [capture.uniqueEventType.eventTypeId];
+                    const id = getEventTypeFor(eventType).id.value;
+                    if (!capture.uniqueEventType.eventTypeIds.includes(id)) capture.uniqueEventType.eventTypeIds.push(id);
+                }
+            }
+
+            for (const property of TypeIntrospector.getTrackedProperties(eventType)) {
+                const metadata = getUniquePropertyMetadata(eventType, property);
+                if (!metadata) continue;
+                const name = metadata.name ?? property;
+                let capture = this._captures.get(name);
+                if (!capture) {
+                    const builder = new ConstraintBuilder(name);
+                    builder.unique(() => {});
+                    capture = builder.capture;
+                    this._captures.set(name, capture);
+                }
+                if (!capture.uniqueConstraint) throw new Error(`Constraint '${name}' is not a unique property constraint.`);
+                assertMatchingScope(name, capture.scope, decoratorScope);
+                if (capture.uniqueConstraint.ignoreCasing) throw new Error(`Conflicting ignoreCasing for unique property constraint '${name}'.`);
+                const unique = new UniqueConstraintBuilder(capture.uniqueConstraint);
+                const id = getEventTypeFor(eventType).id.value;
+                const existing = capture.uniqueConstraint.eventDefinitions.find(definition => definition.eventTypeId === id);
+                if (existing && !existing.properties.includes(property)) {
+                    throw new Error(`Event type '${id}' already added to unique constraint '${name}' with properties '${existing.properties.join(', ')}'.`);
+                }
+                if (!existing) unique.on(eventType, event => (event as Record<string, unknown>)[property]);
+                if (metadata.message && !capture.uniqueConstraint.message) unique.withMessage(metadata.message);
+            }
+        }
+
+        for (const [name, eventTypes] of removalEvents) {
+            const capture = this._captures.get(name);
+            if (capture) {
+                if (capture.uniqueConstraint) {
+                    const unique = new UniqueConstraintBuilder(capture.uniqueConstraint);
+                    eventTypes.forEach(eventType => unique.removedWith(eventType));
+                } else if (capture.uniqueEventType) {
+                    const removedWith = capture.uniqueEventType.removedWithEventTypeIds ??= [];
+                    for (const eventType of eventTypes) {
+                        const id = getEventTypeFor(eventType).id.value;
+                        if (!removedWith.includes(id)) removedWith.push(id);
+                    }
+                }
+            }
         }
     }
 
@@ -85,11 +201,11 @@ export class Constraints implements IConstraints {
                 return {
                     Name: uet.name ?? capture.name,
                     Type: ConstraintType.UniqueEventType,
-                    RemovedWith: [],
+                    RemovedWith: uet.removedWithEventTypeIds ?? [],
                     Definition: {
                         Value0: undefined,
                         Value1: {
-                            EventTypeIds: [uet.eventTypeId]
+                            EventTypeIds: uet.eventTypeIds ?? [uet.eventTypeId]
                         }
                     },
                     Scope: scope
@@ -119,4 +235,21 @@ export class Constraints implements IConstraints {
     hasFor(id: ConstraintId): boolean {
         return this._captures.has(id.value);
     }
+
+    /**
+     * Resolves a configured violation message, preserving the Kernel message when none was supplied.
+     * @param violation - Violation returned by the Kernel.
+     * @returns The violation with its configured message and substituted details, if available.
+     */
+    resolveMessageFor(violation: ConstraintViolation): ConstraintViolation {
+        const capture = this._captures.get(violation.constraintId);
+        const message = capture?.uniqueConstraint?.message ?? capture?.uniqueEventType?.message;
+        if (!message) return violation;
+
+        let resolved = message;
+        for (const [key, value] of Object.entries(violation.details)) {
+            resolved = resolved.replaceAll(`{${key}}`, () => value);
+        }
+        return { ...violation, message: resolved };
+    }
 }

package/events/constraints/for_Constraints/when_combining_decorators_with_fluent_constraints.spec.ts

@@ -0,0 +1,142 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { chai, describe, it, vi } from 'vitest';
+import type { IClientArtifactsProvider } from '../../../artifacts/index.js';
+import type { ChronicleConnection } from '../../../connection/index.js';
+import { eventType } from '../../eventTypeDecorator.js';
+import { constraint } from '../constraint.js';
+import { Constraints } from '../Constraints.js';
+import type { IConstraint } from '../IConstraint.js';
+import type { IConstraintBuilder } from '../IConstraintBuilder.js';
+import { unique } from '../unique.js';
+import { removeConstraint } from '../removeConstraint.js';
+
+const should = chai.should();
+
+class Once {}
+class Again {}
+class Released {}
+class ValueClaimed { address = ''; second = ''; }
+for (const [type, id] of [[Once, 'once'], [Again, 'again'], [Released, 'released'], [ValueClaimed, 'value-claimed']] as const) eventType(id)(type);
+unique('OneRegistration')(Once);
+unique('OneRegistration')(Again);
+unique('Shared')(ValueClaimed.prototype, 'address');
+removeConstraint('OneRegistration')(Released);
+
+class FluentOnce implements IConstraint {
+    define(builder: IConstraintBuilder): void {
+        builder.uniqueFor(Once, 'Registered {email}', 'OneRegistration');
+    }
+}
+constraint('FluentOnce')(FluentOnce);
+
+class FluentWithoutMessage implements IConstraint {
+    define(builder: IConstraintBuilder): void {
+        builder.uniqueFor(Once, undefined, 'OneRegistration');
+    }
+}
+constraint('FluentWithoutMessage')(FluentWithoutMessage);
+
+class FluentValue implements IConstraint {
+    define(builder: IConstraintBuilder): void {
+        builder.unique(uniqueBuilder => uniqueBuilder.on(ValueClaimed, event => event.address));
+    }
+}
+constraint('Shared')(FluentValue);
+
+async function discover(types: Function[], constraintTypes: (new () => IConstraint)[]): Promise<{ definitions: { Name: string; Definition: { Value0?: { EventDefinitions: { Properties: string[] }[] }; Value1?: { EventTypeIds: string[] } }; RemovedWith: string[] }[]; constraints: Constraints }> {
+    const register = vi.fn().mockResolvedValue({});
+    const artifacts = { eventTypes: types, constraints: constraintTypes } as IClientArtifactsProvider;
+    const constraints = new Constraints('store', { constraints: { register } } as unknown as ChronicleConnection, artifacts);
+    await constraints.register();
+    return { definitions: register.mock.calls[0][0].Constraints, constraints };
+}
+
+describe('when combining fluent and decorated unique event type constraints', () => {
+    it('should register one definition per wire name and merge event types and removals', async () => {
+        const { definitions, constraints } = await discover([Once, Again, Released], [FluentOnce]);
+        definitions.length.should.equal(1);
+        definitions[0].Name.should.equal('OneRegistration');
+        definitions[0].Definition.Value1!.EventTypeIds.should.deep.equal(['once', 'again']);
+        definitions[0].RemovedWith.should.deep.equal(['released']);
+        constraints.resolveMessageFor({ constraintId: 'OneRegistration', message: 'Kernel', details: { email: 'a$b' } }).message.should.equal('Registered a$b');
+    });
+});
+
+describe('when merging fluent unique event types with the same name', () => {
+    it('should use the first supplied message', async () => {
+        class Additional {}
+        eventType('additional')(Additional);
+        class FluentWithMessage implements IConstraint {
+            define(builder: IConstraintBuilder): void {
+                builder.uniqueFor(Additional, 'Fluent message', 'OneRegistration');
+            }
+        }
+        constraint('FluentWithMessage')(FluentWithMessage);
+        class Another {}
+        eventType('another')(Another);
+        class FluentWithAnotherMessage implements IConstraint {
+            define(builder: IConstraintBuilder): void {
+                builder.uniqueFor(Another, 'Another message', 'OneRegistration');
+            }
+        }
+        constraint('FluentWithAnotherMessage')(FluentWithAnotherMessage);
+        const { definitions, constraints } = await discover([], [FluentWithoutMessage, FluentWithMessage, FluentWithAnotherMessage]);
+        definitions.length.should.equal(1);
+        definitions[0].Definition.Value1!.EventTypeIds.should.deep.equal(['once', 'additional', 'another']);
+        constraints.resolveMessageFor({ constraintId: 'OneRegistration', message: 'Kernel', details: {} }).message
+            .should.equal('Fluent message');
+    });
+});
+
+describe('when merging a fluent unique event type without a message and a decorated event type with a message', () => {
+    it('should use the decorated message', async () => {
+        class DecoratedOnce {}
+        eventType('decorated-once')(DecoratedOnce);
+        unique('OneRegistration', 'Decorated message')(DecoratedOnce);
+        const { constraints } = await discover([DecoratedOnce], [FluentWithoutMessage]);
+        constraints.resolveMessageFor({ constraintId: 'OneRegistration', message: 'Kernel', details: {} }).message
+            .should.equal('Decorated message');
+    });
+});
+
+describe('when combining fluent and decorated unique properties', () => {
+    it('should not register the same property twice', async () => {
+        const { definitions } = await discover([ValueClaimed], [FluentValue]);
+        definitions.length.should.equal(1);
+        definitions[0].Definition.Value0!.EventDefinitions[0].Properties.should.deep.equal(['address']);
+    });
+});
+
+describe('when a fluent property constraint and decorated event type share a name', () => {
+    it('should reject conflicting constraint definitions', async () => {
+        class Conflicting implements IConstraint {
+            define(builder: IConstraintBuilder): void {
+                builder.unique(uniqueBuilder => uniqueBuilder.on(ValueClaimed, event => event.address));
+            }
+        }
+        constraint('OneRegistration')(Conflicting);
+        const artifacts = { eventTypes: [Once], constraints: [Conflicting] } as unknown as IClientArtifactsProvider;
+        const constraints = new Constraints('store', {} as ChronicleConnection, artifacts);
+        await constraints.discover().then(
+            () => should.fail('Expected conflicting constraint types'),
+            (error: Error) => error.message.should.match(/not a unique event type constraint/)
+        );
+    });
+});
+
+describe('when decorating two properties on the same event with one unique name', () => {
+    it('should reject the second property instead of silently making a compound key', async () => {
+        class PairedValues { address = ''; second = ''; }
+        eventType('paired-values')(PairedValues);
+        unique('Pair')(PairedValues.prototype, 'address');
+        unique('Pair')(PairedValues.prototype, 'second');
+        const artifacts = { eventTypes: [PairedValues], constraints: [] } as unknown as IClientArtifactsProvider;
+        const constraints = new Constraints('store', {} as ChronicleConnection, artifacts);
+        await constraints.discover().then(
+            () => should.fail('Expected a duplicate event type error'),
+            (error: Error) => error.message.should.match(/already added to unique constraint 'Pair'/)
+        );
+    });
+});

package/events/constraints/for_Constraints/when_inheriting_removal_decorators.legacy.spec.ts

@@ -0,0 +1,36 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { chai, describe, it, vi } from 'vitest';
+import type { IClientArtifactsProvider } from '../../../artifacts/index.js';
+import type { ChronicleConnection } from '../../../connection/index.js';
+import { eventType } from '../../eventTypeDecorator.js';
+import { Constraints } from '../Constraints.js';
+import { removeConstraint } from '../removeConstraint.js';
+import { unique } from '../unique.js';
+
+const should = chai.should();
+
+@eventType('legacy-reserved')
+class Reserved {
+    @unique('LegacyValue', 'Already reserved') value = '';
+}
+
+@removeConstraint('LegacyValue')
+class BaseRelease {}
+
+@eventType('legacy-released')
+class Released extends BaseRelease {}
+
+describe('when registering legacy decorators with an inherited removal', () => {
+    it('should register the inherited removal and the decorated property', async () => {
+        const register = vi.fn().mockResolvedValue({});
+        const artifacts = { eventTypes: [Reserved, Released], constraints: [] } as unknown as IClientArtifactsProvider;
+        const constraints = new Constraints('store', { constraints: { register } } as unknown as ChronicleConnection, artifacts);
+        await constraints.register();
+        const definition = register.mock.calls[0][0].Constraints[0];
+        definition.Name.should.equal('LegacyValue');
+        definition.Definition.Value0.EventDefinitions.should.deep.equal([{ EventTypeId: 'legacy-reserved', Properties: ['value'] }]);
+        definition.RemovedWith.should.deep.equal(['legacy-released']);
+    });
+});

package/events/constraints/for_Constraints/when_registering_decorated_constraints.spec.ts

@@ -0,0 +1,63 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { chai, describe, it, vi } from 'vitest';
+import { ConstraintType } from '@cratis/chronicle.contracts';
+import type { ChronicleConnection } from '../../../connection/ChronicleConnection.js';
+import type { IClientArtifactsProvider } from '../../../artifacts/IClientArtifactsProvider.js';
+import { eventType } from '../../eventTypeDecorator.js';
+import { constraint } from '../constraint.js';
+import { Constraints } from '../Constraints.js';
+import type { IConstraint } from '../IConstraint.js';
+import type { IConstraintBuilder } from '../IConstraintBuilder.js';
+import { unique, getUniquePropertyMetadata } from '../unique.js';
+import { removeConstraint } from '../removeConstraint.js';
+
+const should = chai.should();
+
+class Registered { address = ''; }
+class AddressChanged { contact = ''; }
+class Abandoned {}
+class Deleted {}
+class Reset {}
+for (const [type, id] of [
+    [Registered, 'decorator-registered'], [AddressChanged, 'decorator-changed'],
+    [Abandoned, 'decorator-abandoned'], [Deleted, 'decorator-deleted'], [Reset, 'decorator-reset']
+] as const) eventType(id)(type);
+unique('SharedAddress', 'Address {email} already registered')(Registered.prototype, 'address');
+unique('SharedAddress')(AddressChanged.prototype, 'contact');
+removeConstraint('SharedAddress')(Abandoned);
+removeConstraint('SharedAddress')(Deleted);
+removeConstraint('SharedAddress')(Reset);
+
+class FluentAddress implements IConstraint {
+    define(builder: IConstraintBuilder): void {
+        builder.unique(uniqueBuilder => {
+            uniqueBuilder.on(Registered, event => event.address);
+            uniqueBuilder.on(AddressChanged, event => event.contact);
+            uniqueBuilder.withMessage('Address {email} already registered');
+            uniqueBuilder.removedWith(Abandoned).removedWith(Deleted).removedWith(Reset);
+        });
+    }
+}
+constraint('SharedAddress')(FluentAddress);
+
+async function register(types: Function[], constraintTypes: (new () => IConstraint)[] = []) {
+    const send = vi.fn().mockResolvedValue({});
+    const connection = { constraints: { register: send } } as unknown as ChronicleConnection;
+    const artifacts = { eventTypes: types, constraints: constraintTypes } as IClientArtifactsProvider;
+    await new Constraints('store', connection, artifacts).register();
+    return send.mock.calls[0][0].Constraints;
+}
+
+describe('when registering decorated unique properties', () => {
+    it('should group properties by name with all releasing events and match the fluent definition', async () => {
+        const decorated = (await register([Registered, AddressChanged, Abandoned, Deleted, Reset]))[0];
+        const fluent = (await register([], [FluentAddress]))[0];
+        decorated.should.deep.equal(fluent);
+        decorated.Type.should.equal(ConstraintType.Unique);
+        decorated.RemovedWith.should.deep.equal(['decorator-abandoned', 'decorator-deleted', 'decorator-reset']);
+        should.equal(decorated.Definition.Value0.IgnoreCasing, false);
+        getUniquePropertyMetadata(Registered, 'address')!.message!.should.equal('Address {email} already registered');
+    });
+});

package/events/constraints/for_Constraints/when_registering_decorated_event_types.spec.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 { chai, describe, it, vi } from 'vitest';
+import { ConstraintType } from '@cratis/chronicle.contracts';
+import type { ChronicleConnection } from '../../../connection/ChronicleConnection.js';
+import type { IClientArtifactsProvider } from '../../../artifacts/IClientArtifactsProvider.js';
+import { eventType } from '../../eventTypeDecorator.js';
+import { constraint } from '../constraint.js';
+import { Constraints } from '../Constraints.js';
+import type { IConstraint } from '../IConstraint.js';
+import type { IConstraintBuilder } from '../IConstraintBuilder.js';
+import { unique } from '../unique.js';
+import { removeConstraint } from '../removeConstraint.js';
+
+const should = chai.should();
+class OnlyOnce {}
+class Alternate {}
+class Reset {}
+class DefaultName { value = ''; }
+class DefaultEventType {}
+for (const [type, id] of [
+    [OnlyOnce, 'decorator-once'], [Alternate, 'decorator-alternate'], [Reset, 'decorator-reset'],
+    [DefaultName, 'decorator-default'], [DefaultEventType, 'decorator-default-event']
+] as const) eventType(id)(type);
+unique()(DefaultName.prototype, 'value');
+unique()(DefaultEventType);
+unique('OneRegistration', 'Already registered')(OnlyOnce);
+unique('OneRegistration')(Alternate);
+removeConstraint('OneRegistration')(Reset);
+
+class FluentRegistration implements IConstraint {
+    define(builder: IConstraintBuilder): void {
+        builder.uniqueFor(OnlyOnce, 'Already registered', 'OneRegistration');
+    }
+}
+constraint('OneRegistration')(FluentRegistration);
+
+async function register(types: Function[], constraintTypes: (new () => IConstraint)[] = []) {
+    const send = vi.fn().mockResolvedValue({});
+    const connection = { constraints: { register: send } } as unknown as ChronicleConnection;
+    const artifacts = { eventTypes: types, constraints: constraintTypes } as IClientArtifactsProvider;
+    await new Constraints('store', connection, artifacts).register();
+    return send.mock.calls[0][0].Constraints;
+}
+
+describe('when registering decorated event types', () => {
+    it('should use the property name as the default property constraint name', async () => {
+        const definitions = await register([DefaultName]);
+        definitions[0].Name.should.equal('value');
+        definitions[0].Definition.Value0.EventDefinitions.should.deep.equal([{ EventTypeId: 'decorator-default', Properties: ['value'] }]);
+    });
+
+    it('should use the class name rather than the event type id as the default event constraint name', async () => {
+        const definitions = await register([DefaultEventType]);
+        definitions[0].Name.should.equal('DefaultEventType');
+        definitions[0].Definition.Value1.EventTypeIds.should.deep.equal(['decorator-default-event']);
+    });
+
+    it('should match the fluent unique event type definition', async () => {
+        const decorated = (await register([OnlyOnce]))[0];
+        const fluent = (await register([], [FluentRegistration]))[0];
+        decorated.should.deep.equal(fluent);
+    });
+
+    it('should group class-level unique declarations sharing a name', async () => {
+        const definitions = await register([OnlyOnce, Alternate, Reset]);
+        definitions.length.should.equal(1);
+        definitions[0].Type.should.equal(ConstraintType.UniqueEventType);
+        definitions[0].Definition.Value1.EventTypeIds.should.deep.equal(['decorator-once', 'decorator-alternate']);
+        definitions[0].RemovedWith.should.deep.equal(['decorator-reset']);
+    });
+
+    it('should retain the first supplied message when the first declaration has none', async () => {
+        class First {}
+        class Second {}
+        class Third {}
+        eventType('first-registration')(First);
+        eventType('second-registration')(Second);
+        eventType('third-registration')(Third);
+        unique('SharedRegistration')(First);
+        unique('SharedRegistration', 'Second message')(Second);
+        unique('SharedRegistration', 'Third message')(Third);
+        const artifacts = { eventTypes: [First, Second, Third], constraints: [] } as IClientArtifactsProvider;
+        const constraints = new Constraints('store', {} as ChronicleConnection, artifacts);
+        await constraints.discover();
+        constraints.resolveMessageFor({ constraintId: 'SharedRegistration', message: 'Kernel', details: {} }).message
+            .should.equal('Second message');
+    });
+});