@cratis/chronicle 6.7.1 → 6.9.0

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');
+    });
+});

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

@@ -0,0 +1,108 @@
+// 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 } 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';
+
+const should = chai.should();
+
+async function assertDiscoveryFails(eventTypes: Function[], constraintTypes: (new () => IConstraint)[], message: RegExp): Promise<void> {
+    const artifacts = { eventTypes, constraints: constraintTypes } as IClientArtifactsProvider;
+    const constraints = new Constraints('store', {} as ChronicleConnection, artifacts);
+    await constraints.discover().then(
+        () => should.fail('Expected incompatible constraint definitions'),
+        (error: Error) => error.message.should.match(message)
+    );
+}
+
+describe('when two fluent unique event type constraints use the same class id', () => {
+    it('should reject the duplicate id even if their wire names differ', async () => {
+        class First {}
+        class Second {}
+        eventType('merge-first')(First);
+        eventType('merge-second')(Second);
+        class FirstConstraint implements IConstraint {
+            define(builder: IConstraintBuilder): void { builder.uniqueFor(First, undefined, 'FirstName'); }
+        }
+        class SecondConstraint implements IConstraint {
+            define(builder: IConstraintBuilder): void { builder.uniqueFor(Second, undefined, 'SecondName'); }
+        }
+        constraint('SharedId')(FirstConstraint);
+        constraint('SharedId')(SecondConstraint);
+        await assertDiscoveryFails([], [FirstConstraint, SecondConstraint], /Duplicate constraint id 'SharedId'/);
+    });
+});
+
+describe('when merging fluent unique event types with different scopes', () => {
+    it('should reject the conflicting scope', async () => {
+        class First {}
+        class Second {}
+        eventType('merge-first')(First);
+        eventType('merge-second')(Second);
+        class Global implements IConstraint {
+            define(builder: IConstraintBuilder): void { builder.uniqueFor(First, undefined, 'Shared'); }
+        }
+        class Scoped implements IConstraint {
+            define(builder: IConstraintBuilder): void { builder.perEventStreamId().uniqueFor(Second, undefined, 'Shared'); }
+        }
+        constraint('Global')(Global);
+        constraint('Scoped')(Scoped);
+        await assertDiscoveryFails([], [Global, Scoped], /Conflicting scopes for constraint 'Shared'/);
+    });
+});
+
+describe('when merging a scoped fluent unique event type with a decorator', () => {
+    it('should reject the conflicting scope', async () => {
+        class First {}
+        class Second {}
+        eventType('merge-first')(First);
+        eventType('merge-second')(Second);
+        class Scoped implements IConstraint {
+            define(builder: IConstraintBuilder): void { builder.perEventSourceType().uniqueFor(First, undefined, 'Shared'); }
+        }
+        constraint('ScopedEvent')(Scoped);
+        unique('Shared')(Second);
+        await assertDiscoveryFails([Second], [Scoped], /Conflicting scopes for constraint 'Shared'/);
+    });
+});
+
+describe('when merging a scoped fluent unique property with a decorator', () => {
+    it('should reject the conflicting scope', async () => {
+        class First { address = ''; }
+        class Second { address = ''; }
+        eventType('merge-first')(First);
+        eventType('merge-second')(Second);
+        class Scoped implements IConstraint {
+            define(builder: IConstraintBuilder): void {
+                builder.perEventStreamType().unique(uniqueBuilder => uniqueBuilder.on(First, event => event.address));
+            }
+        }
+        constraint('SharedProperty')(Scoped);
+        unique('SharedProperty')(Second.prototype, 'address');
+        await assertDiscoveryFails([Second], [Scoped], /Conflicting scopes for constraint 'SharedProperty'/);
+    });
+});
+
+describe('when merging a case-insensitive fluent unique property with a decorator', () => {
+    it('should reject the conflicting casing setting', async () => {
+        class First { address = ''; }
+        class Second { address = ''; }
+        eventType('merge-first')(First);
+        eventType('merge-second')(Second);
+        class CaseInsensitive implements IConstraint {
+            define(builder: IConstraintBuilder): void {
+                builder.unique(uniqueBuilder => uniqueBuilder.on(First, event => event.address).ignoreCasing());
+            }
+        }
+        constraint('SharedProperty')(CaseInsensitive);
+        unique('SharedProperty')(Second.prototype, 'address');
+        await assertDiscoveryFails([Second], [CaseInsensitive], /Conflicting ignoreCasing for unique property constraint 'SharedProperty'/);
+    });
+});

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

@@ -0,0 +1,92 @@
+// 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 { ChronicleConnection } from '../../../connection/ChronicleConnection.js';
+import type { IClientArtifactsProvider } from '../../../artifacts/IClientArtifactsProvider.js';
+import { EventSequence } from '../../../eventSequences/EventSequence.js';
+import { EventSequenceId } from '../../../eventSequences/EventSequenceId.js';
+import type { IUnitOfWorkManager } from '../../../transactions/IUnitOfWorkManager.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';
+
+const should = chai.should();
+class Registered { email = ''; }
+class OnlyOnce {}
+eventType('message-registered')(Registered);
+eventType('message-once')(OnlyOnce);
+unique('SharedAddress', 'Address {email} already registered')(Registered.prototype, 'email');
+unique('OneRegistration', 'Already registered')(OnlyOnce);
+
+class FluentRegistration implements IConstraint {
+    define(builder: IConstraintBuilder): void {
+        builder.uniqueFor(OnlyOnce, 'Already registered', 'OneRegistration');
+    }
+}
+constraint('FluentRegistration')(FluentRegistration);
+
+class FluentAddress implements IConstraint {
+    define(builder: IConstraintBuilder): void {
+        builder.unique(uniqueBuilder => uniqueBuilder.on(Registered, event => event.email).withMessage('Address {email} already registered'));
+    }
+}
+constraint('SharedAddress')(FluentAddress);
+
+function constraints(types: Function[], constraintTypes: (new () => IConstraint)[] = []): Constraints {
+    const artifacts = { eventTypes: types, constraints: constraintTypes } as IClientArtifactsProvider;
+    return new Constraints('store', { constraints: { register: vi.fn() } } as unknown as ChronicleConnection, artifacts);
+}
+
+describe('when resolving violation messages', () => {
+    it('should substitute detail values literally and preserve unknown violations', async () => {
+        const discovered = constraints([Registered]);
+        await discovered.discover();
+        discovered.resolveMessageFor({ constraintId: 'SharedAddress', message: 'Kernel', details: { email: '$& $$ $` $\'' } }).message
+            .should.equal('Address $& $$ $` $\' already registered');
+        const violation = { constraintId: 'unknown', message: 'Kernel default', details: {} };
+        discovered.resolveMessageFor(violation).should.equal(violation);
+    });
+
+    it('should resolve fluent withMessage values on append results', async () => {
+        const discovered = constraints([Registered], [FluentAddress]);
+        await discovered.discover();
+        const connection = {
+            eventSequences: { append: vi.fn().mockResolvedValue({ Response: {
+                SequenceNumber: 0n, Errors: [], ConstraintViolations: [{
+                    ConstraintId: 'SharedAddress', Message: 'Kernel default', Details: { email: 'a$b' }
+                }]
+            } }) }
+        } as unknown as ChronicleConnection;
+        const sequence = new EventSequence(EventSequenceId.eventLog, 'store', 'namespace', connection,
+            {} as IUnitOfWorkManager, discovered.resolveMessageFor.bind(discovered));
+        const result = await sequence.append('source', new Registered());
+        result.constraintViolations[0].message.should.equal('Address a$b already registered');
+    });
+
+    it('should resolve a named fluent event type with a different class id', async () => {
+        const discovered = constraints([], [FluentRegistration]);
+        await discovered.discover();
+        discovered.resolveMessageFor({ constraintId: 'OneRegistration', message: 'Kernel', details: {} }).message
+            .should.equal('Already registered');
+    });
+
+    it('should resolve decorated event type messages on append results', async () => {
+        const discovered = constraints([OnlyOnce]);
+        await discovered.discover();
+        const connection = {
+            eventSequences: { append: vi.fn().mockResolvedValue({ Response: {
+                SequenceNumber: 0n, Errors: [], ConstraintViolations: [{
+                    ConstraintId: 'OneRegistration', Message: 'Kernel default', Details: {}
+                }]
+            } }) }
+        } as unknown as ChronicleConnection;
+        const sequence = new EventSequence(EventSequenceId.eventLog, 'store', 'namespace', connection,
+            {} as IUnitOfWorkManager, discovered.resolveMessageFor.bind(discovered));
+        const result = await sequence.append('source', new OnlyOnce());
+        result.constraintViolations[0].message.should.equal('Already registered');
+    });
+});

package/events/constraints/index.ts

@@ -6,6 +6,8 @@ export type { IConstraint } from './IConstraint.js';
 export type { IConstraintBuilder } from './IConstraintBuilder.js';
 export type { IUniqueConstraintBuilder } from './IUniqueConstraintBuilder.js';
 export { constraint, getConstraintMetadata, isConstraint } from './constraint.js';
+export { unique } from './unique.js';
+export { removeConstraint } from './removeConstraint.js';
 export type { ConstraintMetadata } from './constraint.js';
 export type { IConstraints } from './IConstraints.js';
 export { Constraints } from './Constraints.js';

package/events/constraints/removeConstraint.ts

@@ -0,0 +1,28 @@
+// 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 { ChronicleClassDecorator } from '../../types/standardDecoratorMetadata.js';
+
+const KEY = 'chronicle:constraint:remove';
+
+/**
+ * Marks an event class as releasing a named constraint when appended. May be applied repeatedly.
+ * @param name - Exact name of the constraint to release.
+ * @returns A class decorator.
+ */
+export function removeConstraint(name: string): ChronicleClassDecorator {
+    return (target: object) => {
+        const existing = Reflect.getOwnMetadata(KEY, target) as string[] | undefined ?? [];
+        Reflect.defineMetadata(KEY, [...existing, name], target);
+    };
+}
+
+/** Gets the constraint names released by this event class. */
+export function getRemovedConstraintNames(type: Function): string[] {
+    const names: string[] = [];
+    for (let current: object | null = type; current && current !== Function.prototype; current = Object.getPrototypeOf(current)) {
+        names.push(...(Reflect.getOwnMetadata(KEY, current) as string[] | undefined ?? []));
+    }
+    return [...new Set(names)];
+}

package/events/constraints/unique.ts

@@ -0,0 +1,45 @@
+// 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 { ChronicleClassOrPropertyDecorator, decorateClassOrProperty, getPropertyMetadata, getTypeOrFieldMetadata } from '../../types/propertyDecoratorMetadata.js';
+import { TypeIntrospector } from '../../types/TypeIntrospector.js';
+
+const CLASS_KEY = 'chronicle:constraint:unique:class';
+const PROPERTY_KEY = 'chronicle:constraint:unique:property';
+
+interface UniqueMetadata {
+    name?: string;
+    message?: string;
+}
+
+/**
+ * Marks an event class as unique per event source, or an event property as unique across event sources.
+ * The optional name defaults to the class or property name. Like the .NET attribute, this decorator
+ * does not offer ignore-casing; use a fluent constraint for case-insensitive uniqueness.
+ * @param name - Optional shared constraint name.
+ * @param message - Optional fixed violation message.
+ * @returns A class or public instance field decorator.
+ */
+export function unique(name?: string, message?: string): ChronicleClassOrPropertyDecorator {
+    return decorateClassOrProperty((target, property) => {
+        const metadata: UniqueMetadata = { name, message };
+        if (property !== undefined) {
+            const key = property.toString();
+            TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, key);
+            Reflect.defineMetadata(PROPERTY_KEY, metadata, target, key);
+        } else {
+            Reflect.defineMetadata(CLASS_KEY, metadata, target);
+        }
+    });
+}
+
+/** Gets the unique constraint declared on an event class, if present. */
+export function getUniqueEventMetadata(type: Function): UniqueMetadata | undefined {
+    return getTypeOrFieldMetadata<UniqueMetadata>(CLASS_KEY, type);
+}
+
+/** Gets the unique constraint declared on an event property, if present. */
+export function getUniquePropertyMetadata(type: Function, property: string): UniqueMetadata | undefined {
+    return getPropertyMetadata<UniqueMetadata>(PROPERTY_KEY, type.prototype, property);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/chronicle",
-    "version": "6.7.1",
+    "version": "6.9.0",
     "description": "Event sourcing for TypeScript and Node.js — the idiomatic client for Cratis Chronicle, the open-source event-sourcing database",
     "author": "Cratis",
     "license": "MIT",
@@ -162,7 +162,7 @@
         "build": "tsc -b",
         "clean": "rm -rf dist",
         "test": "vitest run",
-        "test:standard-types": "tsc --ignoreConfig --noEmit --target es2022 --module es2022 --moduleResolution bundler --lib es2022,esnext.decorators --types node --skipLibCheck --strict schemas/decorators.standard.spec.ts projections/modelBound/decorators.standard.spec.ts events/classDecorators.standard.spec.ts readModels/standardFallbacks.standard.spec.ts artifacts/validateArtifactSchemas.spec.ts",
+        "test:standard-types": "tsc --ignoreConfig --noEmit --target es2022 --module es2022 --moduleResolution bundler --lib es2022,esnext.decorators --types node --skipLibCheck --strict schemas/decorators.standard.spec.ts projections/modelBound/decorators.standard.spec.ts events/classDecorators.standard.spec.ts reactors/decorators.standard.spec.ts readModels/standardFallbacks.standard.spec.ts artifacts/validateArtifactSchemas.spec.ts",
         "test:native": "node ./scripts/check-native-esm.mjs"
     },
     "dependencies": {