@cratis/chronicle 6.50.0 → 6.51.0

package/events/constraints/UniqueOptions.ts

@@ -0,0 +1,20 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { ConstraintEventSequence } from './ConstraintEventSequences.js';
+
+/** Options for the {@link unique} decorator. Mirrors the .NET UniqueAttribute. */
+export interface UniqueOptions {
+    /** Optional shared constraint name; defaults to the class or property name. */
+    name?: string;
+
+    /** Optional fixed violation message. */
+    message?: string;
+
+    /**
+     * The event sequences the constraint applies to. Empty or omitted means every event sequence.
+     * When several declarations share a constraint name, their event sequences are combined, and a
+     * declaration naming none keeps the constraint applying to every event sequence.
+     */
+    eventSequences?: ConstraintEventSequence[];
+}

package/events/constraints/for_Constraints/against_a_kernel/when_appending_to_event_sequences_a_constraint_is_scoped_to.integration.spec.ts

@@ -0,0 +1,118 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { randomUUID } from 'node:crypto';
+import { afterAll, beforeAll, chai, describe, it } from 'vitest';
+import { field } from '@cratis/fundamentals';
+import { ChronicleClient } from '../../../../ChronicleClient.js';
+import { ChronicleOptions } from '../../../../ChronicleOptions.js';
+import type { IClientArtifactsProvider } from '../../../../artifacts/index.js';
+import { EventSequenceId } from '../../../../eventSequences/EventSequenceId.js';
+import type { IEventSequence } from '../../../../eventSequences/IEventSequence.js';
+import type { IEventStore } from '../../../../IEventStore.js';
+import { eventType } from '../../../eventTypeDecorator.js';
+import { constraint } from '../../constraint.js';
+import type { IConstraint } from '../../IConstraint.js';
+import type { IConstraintBuilder } from '../../IConstraintBuilder.js';
+import { unique } from '../../unique.js';
+
+chai.should();
+
+// Runs against a real Chronicle kernel; skipped locally unless the connection string is set (see vitest.integration.config.ts).
+const connectionString = process.env.CHRONICLE_INTEGRATION_CONNECTION_STRING;
+
+@eventType()
+class HandleClaimed {
+    @field(String) handle = '';
+}
+
+@eventType()
+class NicknameClaimed {
+    @field(String) nickname = '';
+}
+
+@eventType()
+@unique({ name: 'OneProfilePerUser', eventSequences: [EventSequenceId.eventLog] })
+class ProfileCreated {
+    @field(String) label = '';
+}
+
+@constraint('UniqueHandleOnEventLog')
+class UniqueHandleOnEventLog implements IConstraint {
+    define(builder: IConstraintBuilder): void {
+        builder.forEventLog().unique(_ => _.on(HandleClaimed, e => e.handle));
+    }
+}
+
+@constraint('UniqueNicknameEverywhere')
+class UniqueNicknameEverywhere implements IConstraint {
+    define(builder: IConstraintBuilder): void {
+        builder.unique(_ => _.on(NicknameClaimed, e => e.nickname));
+    }
+}
+
+const artifacts: IClientArtifactsProvider = {
+    eventTypes: [HandleClaimed, NicknameClaimed, ProfileCreated],
+    readModels: [],
+    reactors: [],
+    reducers: [],
+    seeders: [],
+    constraints: [UniqueHandleOnEventLog, UniqueNicknameEverywhere],
+    projections: [],
+    webhooks: [],
+    eventTypeMigrations: [],
+    globalForHandlers: []
+};
+
+const handle = (value: string) => Object.assign(new HandleClaimed(), { handle: value });
+const nickname = (value: string) => Object.assign(new NicknameClaimed(), { nickname: value });
+
+describe.skipIf(!connectionString && !process.env.CI)('when appending to event sequences a constraint is scoped to against a kernel', () => {
+    const storeName = `Sequenced${randomUUID().replaceAll('-', '').slice(0, 12)}`;
+    let client: ChronicleClient;
+    let store: IEventStore;
+    let outbox: IEventSequence;
+
+    beforeAll(async () => {
+        client = new ChronicleClient(ChronicleOptions.fromConnectionString(connectionString!, {
+            discoveryPatterns: [],
+            clientArtifactsProvider: artifacts
+        }));
+        store = await client.getEventStore(storeName);
+        outbox = store.getEventSequence(new EventSequenceId('outbox'));
+    });
+
+    afterAll(() => client?.dispose());
+
+    it('validates an event-log constraint on the event log', async () => {
+        (await store.eventLog.append(randomUUID(), handle('ada'))).isSuccess.should.be.true;
+        const rejected = await store.eventLog.append(randomUUID(), handle('ada'));
+        rejected.isSuccess.should.be.false;
+        rejected.constraintViolations[0].constraintId.should.equal('UniqueHandleOnEventLog');
+    });
+
+    it('neither validates nor claims an event-log constraint in the outbox', async () => {
+        (await store.eventLog.append(randomUUID(), handle('grace'))).isSuccess.should.be.true;
+        (await outbox.append(randomUUID(), handle('grace'))).isSuccess.should.be.true;
+        (await outbox.append(randomUUID(), handle('grace'))).isSuccess.should.be.true;
+    });
+
+    it('keeps a forwarded value from claiming the event-log value', async () => {
+        (await outbox.append(randomUUID(), handle('linus'))).isSuccess.should.be.true;
+        (await store.eventLog.append(randomUUID(), handle('linus'))).isSuccess.should.be.true;
+    });
+
+    it('validates a decorated event-log constraint only on the event log', async () => {
+        const source = randomUUID();
+        (await store.eventLog.append(source, new ProfileCreated())).isSuccess.should.be.true;
+        (await store.eventLog.append(source, new ProfileCreated())).isSuccess.should.be.false;
+        (await outbox.append(source, new ProfileCreated())).isSuccess.should.be.true;
+        (await outbox.append(source, new ProfileCreated())).isSuccess.should.be.true;
+    });
+
+    it('validates an unscoped constraint in the outbox against its own index', async () => {
+        (await store.eventLog.append(randomUUID(), nickname('margaret'))).isSuccess.should.be.true;
+        (await outbox.append(randomUUID(), nickname('margaret'))).isSuccess.should.be.true;
+        (await outbox.append(randomUUID(), nickname('margaret'))).isSuccess.should.be.false;
+    });
+});

package/events/constraints/for_Constraints/when_scoping_to_event_sequences/given/registered_constraints.ts

@@ -0,0 +1,26 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { vi } from 'vitest';
+import type { Constraint, RegisterConstraintsRequest } from '@cratis/chronicle.contracts';
+import type { IClientArtifactsProvider } from '../../../../../artifacts/index.js';
+import type { ChronicleConnection } from '../../../../../connection/index.js';
+import { Constraints } from '../../../Constraints.js';
+
+/**
+ * Registers the given constraint classes and decorated event types and returns the registered wire definitions by name.
+ * @param constraints - The constraint classes.
+ * @param eventTypes - The event types whose decorators contribute constraints.
+ * @returns The registered constraints keyed by name.
+ */
+export async function registeredConstraints(constraints: Function[], eventTypes: Function[] = []): Promise<Map<string, Constraint>> {
+    const register = vi.fn().mockResolvedValue({});
+    const connection = { constraints: { register } } as unknown as ChronicleConnection;
+    const artifacts = {
+        eventTypes, readModels: [], reactors: [], reducers: [], seeders: [], constraints,
+        projections: [], webhooks: [], eventTypeMigrations: [], globalForHandlers: []
+    } as unknown as IClientArtifactsProvider;
+    await new Constraints('store', connection, artifacts).register();
+    const request = register.mock.calls[0][0] as RegisterConstraintsRequest;
+    return new Map(request.Constraints.map(registered => [registered.Name, registered]));
+}

package/events/constraints/for_Constraints/when_scoping_to_event_sequences/with_fluent_builder.spec.ts

@@ -0,0 +1,40 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeAll, chai, describe, it } from 'vitest';
+import type { Constraint } from '@cratis/chronicle.contracts';
+import { EventSequenceId } from '../../../../eventSequences/EventSequenceId.js';
+import { eventType } from '../../../eventTypeDecorator.js';
+import { constraint } from '../../constraint.js';
+import type { IConstraintBuilder } from '../../IConstraintBuilder.js';
+import { registeredConstraints } from './given/registered_constraints.js';
+
+chai.should();
+
+class NameRegistered { name = ''; }
+class OnlyOnce {}
+eventType('name-registered')(NameRegistered);
+eventType('only-once')(OnlyOnce);
+
+class UnscopedName { define(builder: IConstraintBuilder) { builder.unique(unique => unique.on(NameRegistered, event => event.name)); } }
+constraint('unscoped-name')(UnscopedName);
+class EventLogName { define(builder: IConstraintBuilder) { builder.unique(unique => unique.on(NameRegistered, event => event.name)).forEventLog(); } }
+constraint('event-log-name')(EventLogName);
+class SelectedOnce {
+    define(builder: IConstraintBuilder) {
+        builder.forEventSequences(new EventSequenceId('outbox'), 'inbox', ' ', 'outbox')
+            .uniqueFor(OnlyOnce, undefined, 'selected-once')
+            .forEventSequences(EventSequenceId.eventLog);
+    }
+}
+constraint('selected-once-constraint')(SelectedOnce);
+
+describe('when scoping constraints to event sequences with the fluent builder', () => {
+    let registered: Map<string, Constraint>;
+    beforeAll(async () => { registered = await registeredConstraints([UnscopedName, EventLogName, SelectedOnce]); });
+
+    it('should register an unscoped constraint for every event sequence', () => registered.get('unscoped-name')!.EventSequences.should.deep.equal([]));
+    it('should register a constraint declared after the definition for the event log', () => registered.get('event-log-name')!.EventSequences.should.deep.equal(['event-log']));
+    it('should register distinct nonblank event sequences across every call in declaration order', () =>
+        registered.get('selected-once')!.EventSequences.should.deep.equal(['outbox', 'inbox', 'event-log']));
+});

package/events/constraints/for_Constraints/when_scoping_to_event_sequences/with_legacy_decorators.legacy.spec.ts

@@ -0,0 +1,47 @@
+// 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 { field } from '@cratis/fundamentals';
+import { beforeAll, chai, describe, it } from 'vitest';
+import type { Constraint } from '@cratis/chronicle.contracts';
+import { EventSequenceId } from '../../../../eventSequences/EventSequenceId.js';
+import { eventType } from '../../../eventTypeDecorator.js';
+import { unique } from '../../unique.js';
+import { registeredConstraints } from './given/registered_constraints.js';
+
+chai.should();
+
+@eventType('legacy-account-opened')
+@unique({ name: 'legacy-one-account', message: 'Already opened', eventSequences: [EventSequenceId.eventLog] })
+class AccountOpened { @field(String) label = ''; }
+
+@eventType('legacy-account-noted')
+@unique('legacy-unscoped-account')
+class AccountNoted { @field(String) label = ''; }
+
+@eventType('legacy-email-registered')
+class EmailRegistered {
+    @field(String) @unique({ name: 'legacy-email', eventSequences: ['event-log'] }) email = '';
+    @field(String) @unique({ name: 'legacy-alias' }) alias = '';
+}
+
+@eventType('legacy-email-forwarded')
+class EmailForwarded {
+    @field(String) @unique({ name: 'legacy-email', eventSequences: ['outbox'] }) email = '';
+    @field(String) @unique({ name: 'legacy-alias', eventSequences: ['outbox'] }) alias = '';
+}
+
+describe('when scoping legacy unique decorators to event sequences', () => {
+    let registered: Map<string, Constraint>;
+    beforeAll(async () => { registered = await registeredConstraints([], [AccountOpened, AccountNoted, EmailRegistered, EmailForwarded]); });
+
+    it('should register a decorated event type for the declared event sequences', () =>
+        registered.get('legacy-one-account')!.EventSequences.should.deep.equal(['event-log']));
+    it('should register the positional form for every event sequence', () =>
+        registered.get('legacy-unscoped-account')!.EventSequences.should.deep.equal([]));
+    it('should combine the event sequences of properties sharing a constraint name', () =>
+        registered.get('legacy-email')!.EventSequences.should.deep.equal(['event-log', 'outbox']));
+    it('should keep a shared constraint applying everywhere when one property names no event sequence', () =>
+        registered.get('legacy-alias')!.EventSequences.should.deep.equal([]));
+});

package/events/constraints/for_Constraints/when_scoping_to_event_sequences/with_merged_declarations.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 { beforeAll, chai, describe, it } from 'vitest';
+import type { Constraint } from '@cratis/chronicle.contracts';
+import { eventType } from '../../../eventTypeDecorator.js';
+import { constraint } from '../../constraint.js';
+import type { IConstraintBuilder } from '../../IConstraintBuilder.js';
+import { registeredConstraints } from './given/registered_constraints.js';
+
+chai.should();
+
+class Opened {}
+class Closed {}
+class Archived {}
+eventType('merge-opened')(Opened);
+eventType('merge-closed')(Closed);
+eventType('merge-archived')(Archived);
+
+class OpenedOnLog { define(builder: IConstraintBuilder) { builder.forEventLog().uniqueFor(Opened, undefined, 'narrowed'); } }
+constraint('opened-on-log')(OpenedOnLog);
+class ClosedOnOutbox { define(builder: IConstraintBuilder) { builder.forEventSequences('outbox').uniqueFor(Closed, undefined, 'narrowed'); } }
+constraint('closed-on-outbox')(ClosedOnOutbox);
+class OpenedEverywhere { define(builder: IConstraintBuilder) { builder.uniqueFor(Opened, undefined, 'widened'); } }
+constraint('opened-everywhere')(OpenedEverywhere);
+class ArchivedOnLog { define(builder: IConstraintBuilder) { builder.forEventLog().uniqueFor(Archived, undefined, 'widened'); } }
+constraint('archived-on-log')(ArchivedOnLog);
+
+describe('when scoping merged unique event type declarations to event sequences', () => {
+    let registered: Map<string, Constraint>;
+    beforeAll(async () => { registered = await registeredConstraints([OpenedOnLog, ClosedOnOutbox, OpenedEverywhere, ArchivedOnLog]); });
+
+    it('should combine the event sequences of every declaration', () => registered.get('narrowed')!.EventSequences.should.deep.equal(['event-log', 'outbox']));
+    it('should keep a constraint applying everywhere when one declaration names no event sequence', () =>
+        registered.get('widened')!.EventSequences.should.deep.equal([]));
+});

package/events/constraints/for_Constraints/when_scoping_to_event_sequences/with_standard_decorators.standard.spec.ts

@@ -0,0 +1,46 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { field } from '@cratis/fundamentals';
+import { beforeAll, chai, describe, it } from 'vitest';
+import type { Constraint } from '@cratis/chronicle.contracts';
+import { EventSequenceId } from '../../../../eventSequences/EventSequenceId.js';
+import { eventType } from '../../../eventTypeDecorator.js';
+import { unique } from '../../unique.js';
+import { registeredConstraints } from './given/registered_constraints.js';
+
+chai.should();
+
+@eventType('standard-account-opened')
+@unique({ name: 'standard-one-account', message: 'Already opened', eventSequences: [EventSequenceId.eventLog] })
+class AccountOpened { @field(String) label = ''; }
+
+@eventType('standard-account-noted')
+@unique('standard-unscoped-account')
+class AccountNoted { @field(String) label = ''; }
+
+@eventType('standard-email-registered')
+class EmailRegistered {
+    @field(String) @unique({ name: 'standard-email', eventSequences: ['event-log'] }) email = '';
+    @field(String) @unique({ name: 'standard-alias' }) alias = '';
+}
+
+@eventType('standard-email-forwarded')
+class EmailForwarded {
+    @field(String) @unique({ name: 'standard-email', eventSequences: ['outbox'] }) email = '';
+    @field(String) @unique({ name: 'standard-alias', eventSequences: ['outbox'] }) alias = '';
+}
+
+describe('when scoping standard unique decorators to event sequences', () => {
+    let registered: Map<string, Constraint>;
+    beforeAll(async () => { registered = await registeredConstraints([], [AccountOpened, AccountNoted, EmailRegistered, EmailForwarded]); });
+
+    it('should register a decorated event type for the declared event sequences', () =>
+        registered.get('standard-one-account')!.EventSequences.should.deep.equal(['event-log']));
+    it('should register the positional form for every event sequence', () =>
+        registered.get('standard-unscoped-account')!.EventSequences.should.deep.equal([]));
+    it('should combine the event sequences of properties sharing a constraint name', () =>
+        registered.get('standard-email')!.EventSequences.should.deep.equal(['event-log', 'outbox']));
+    it('should keep a shared constraint applying everywhere when one property names no event sequence', () =>
+        registered.get('standard-alias')!.EventSequences.should.deep.equal([]));
+});

package/events/constraints/index.ts

@@ -7,6 +7,8 @@ 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 type { UniqueOptions } from './UniqueOptions.js';
+export type { ConstraintEventSequence } from './ConstraintEventSequences.js';
 export { removeConstraint } from './removeConstraint.js';
 export type { ConstraintMetadata } from './constraint.js';
 export type { IConstraints } from './IConstraints.js';

package/events/constraints/unique.ts

@@ -4,6 +4,8 @@
 import 'reflect-metadata';
 import { ChronicleClassOrPropertyDecorator, decorateClassOrProperty, getPropertyMetadata, getTypeOrFieldMetadata } from '../../types/propertyDecoratorMetadata.js';
 import { TypeIntrospector } from '../../types/TypeIntrospector.js';
+import { normalizeConstraintEventSequences } from './ConstraintEventSequences.js';
+import type { UniqueOptions } from './UniqueOptions.js';
 
 const CLASS_KEY = 'chronicle:constraint:unique:class';
 const PROPERTY_KEY = 'chronicle:constraint:unique:property';
@@ -11,6 +13,8 @@ const PROPERTY_KEY = 'chronicle:constraint:unique:property';
 interface UniqueMetadata {
     name?: string;
     message?: string;
+    /** Normalized event sequence identifiers; omitted means every event sequence. */
+    eventSequences?: string[];
 }
 
 /**
@@ -21,9 +25,25 @@ interface UniqueMetadata {
  * @param message - Optional fixed violation message.
  * @returns A class or public instance field decorator.
  */
-export function unique(name?: string, message?: string): ChronicleClassOrPropertyDecorator {
+export function unique(name?: string, message?: string): ChronicleClassOrPropertyDecorator;
+/**
+ * Marks an event class as unique per event source, or an event property as unique across event sources,
+ * optionally applying the constraint only to selected event sequences.
+ * @param options - The constraint name, message and event sequences.
+ * @returns A class or public instance field decorator.
+ */
+export function unique(options: UniqueOptions): ChronicleClassOrPropertyDecorator;
+export function unique(nameOrOptions?: string | UniqueOptions, message?: string): ChronicleClassOrPropertyDecorator {
+    const options: UniqueOptions = typeof nameOrOptions === 'object' && nameOrOptions !== null
+        ? nameOrOptions
+        : { name: nameOrOptions, message };
+    const eventSequences = normalizeConstraintEventSequences(options.eventSequences ?? []);
+    const metadata: UniqueMetadata = {
+        name: options.name,
+        message: options.message,
+        ...(eventSequences.length > 0 ? { eventSequences } : {})
+    };
     return decorateClassOrProperty((target, property) => {
-        const metadata: UniqueMetadata = { name, message };
         if (property !== undefined) {
             const key = property.toString();
             TypeIntrospector.trackProperty((target as { constructor: Function }).constructor, key);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/chronicle",
-    "version": "6.50.0",
+    "version": "6.51.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",
@@ -173,7 +173,7 @@
         "clean": "rm -rf dist",
         "test": "vitest run",
         "test:integration": "vitest run --config vitest.integration.config.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/declarative/addChildCompatibility.standard.spec.ts projections/declarative/for_CompositeKeyBuilder/when_typing_constant_parts.standard.spec.ts projections/modelBound/decorators.standard.spec.ts events/classDecorators.standard.spec.ts reactors/decorators.standard.spec.ts readModels/standardFallbacks.standard.spec.ts readModels/registration.standard.spec.ts for_ChronicleClient/when_registering_artifacts/with_standard_property_mappings.standard.spec.ts artifacts/validateArtifactSchemas.spec.ts testing/for_EventScenario/when_appending_concept_fields/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_scoped_constraints/with_standard_decorators.standard.spec.ts schemas/for_JsonSchemaGenerator/when_generating_children/with_standard_decorators.standard.spec.ts events/for_handles/when_decorating_a_method.standard.spec.ts testing/for_ReadModelScenario/when_evaluating_arithmetic/with_standard_decorators.standard.spec.ts testing/for_ReadModelScenario/when_evaluating_joins/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_field_types/with_standard_decorators.standard.spec.ts eventSequences/for_EventSequence/when_appending/with_subject_annotations.standard.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_from_all.standard.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_tags/with_standard_decorators.standard.spec.ts telemetry/for_ChronicleTelemetry/when_exposing_names/with_convention_names.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_from_all_events.standard.spec.ts events/for_observerFilters/when_registering/with_standard_decorators.standard.spec.ts reactors/for_Reactors/against_a_kernel/when_filtering_source_and_stream_types.integration.spec.ts testing/for_observerScenarios/when_selecting_filters/with_source_and_stream_types.spec.ts readModels/for_ReadModelWatcher/watchCompatibility.standard.spec.ts for_EventStore/when_implementing_a_legacy_event_store.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/declarative/addChildCompatibility.standard.spec.ts projections/declarative/for_CompositeKeyBuilder/when_typing_constant_parts.standard.spec.ts projections/modelBound/decorators.standard.spec.ts events/classDecorators.standard.spec.ts reactors/decorators.standard.spec.ts readModels/standardFallbacks.standard.spec.ts readModels/registration.standard.spec.ts for_ChronicleClient/when_registering_artifacts/with_standard_property_mappings.standard.spec.ts artifacts/validateArtifactSchemas.spec.ts testing/for_EventScenario/when_appending_concept_fields/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_scoped_constraints/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_event_sequence_constraints/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_event_sequence_constraints/other_sequence_extended_key.standard.spec.ts events/constraints/for_Constraints/when_scoping_to_event_sequences/with_standard_decorators.standard.spec.ts schemas/for_JsonSchemaGenerator/when_generating_children/with_standard_decorators.standard.spec.ts events/for_handles/when_decorating_a_method.standard.spec.ts testing/for_ReadModelScenario/when_evaluating_arithmetic/with_standard_decorators.standard.spec.ts testing/for_ReadModelScenario/when_evaluating_joins/with_standard_decorators.standard.spec.ts testing/for_EventScenario/when_appending_field_types/with_standard_decorators.standard.spec.ts eventSequences/for_EventSequence/when_appending/with_subject_annotations.standard.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_from_all.standard.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_tags/with_standard_decorators.standard.spec.ts telemetry/for_ChronicleTelemetry/when_exposing_names/with_convention_names.spec.ts projections/for_ProjectionDefinitionCompiler/when_compiling_from_all_events.standard.spec.ts events/for_observerFilters/when_registering/with_standard_decorators.standard.spec.ts reactors/for_Reactors/against_a_kernel/when_filtering_source_and_stream_types.integration.spec.ts testing/for_observerScenarios/when_selecting_filters/with_source_and_stream_types.spec.ts readModels/for_ReadModelWatcher/watchCompatibility.standard.spec.ts for_EventStore/when_implementing_a_legacy_event_store.spec.ts",
         "test:native": "node ./scripts/check-native-esm.mjs"
     },
     "dependencies": {

package/testing/EventScenario.fixtures.spec.ts

@@ -59,7 +59,7 @@ const fixtures = readdirSync(directory).filter(name => name.endsWith('.json') &&
     !['batches.json', 'batch-omitted-routes.json', 'batch-rollback.json', 'builders.json', 'constraints.json', 'constraints-isolation.json', 'constraints-key-domain.json',
         'constraints-property-lifecycle.json', 'constraints-property-covered-removal.json', 'constraints-event-type-cycles.json',
         'constraints-event-type-siblings.json', 'constraints-composite.json',
-        'constraints-ignore-casing.json', 'constraints-scopes.json', 'constraints-field-types.json'].includes(name)).map(name => ({
+        'constraints-ignore-casing.json', 'constraints-scopes.json', 'constraints-field-types.json', 'constraints-event-sequences.json'].includes(name)).map(name => ({
     name, fixture: JSON.parse(readFileSync(new URL(name, directory), 'utf8')) as Fixture
 }));
 const artifacts = { eventTypes: [OracleEventRecorded, AlternateRecorded, BoundaryRecorded], constraints: [] };

package/testing/EventScenario.ts

@@ -85,9 +85,15 @@ export class EventScenario {
                         }
                     }
                 }
-                constraints = new InProcessConstraints(definitions, new Map(eventTypes.map(type =>
-                    [getEventTypeFor(type).id.value, getEventTypeMetadata(type)!.schema])));
-                for (const [name, capture] of definitions) {
+                // The scenario appends to the event log only. A definition scoped to other event sequences is neither
+                // validated nor indexed there by the kernel (constraints-event-sequences.json), so it takes no part.
+                const eventLog = EventSequenceId.eventLog.value;
+                const applicable = new Map([...definitions].filter(([, capture]) =>
+                    !capture.eventSequences?.length || capture.eventSequences.includes(eventLog)));
+                const inapplicable = new Set([...definitions.keys()].filter(name => !applicable.has(name)));
+                constraints = new InProcessConstraints(applicable, new Map(eventTypes.map(type =>
+                    [getEventTypeFor(type).id.value, getEventTypeMetadata(type)!.schema])), inapplicable);
+                for (const [name, capture] of applicable) {
                     const ids = capture.uniqueConstraint?.eventDefinitions.map(entry => entry.eventTypeId) ??
                         capture.uniqueEventType?.eventTypeIds ?? [capture.uniqueEventType?.eventTypeId];
                     const removedWith = [...(capture.uniqueConstraint?.removedWithEventTypeIds ?? []),
@@ -121,7 +127,7 @@ export class EventScenario {
                                 `Unique keys with schema ${schema?.type ?? 'missing'}/${schema?.format ?? 'unformatted'} are not fixture-backed; date, object and other numeric formats require a kernel-backed test.`);
                         }
                         const extendedKey = schemas.some(schema => schema?.type === 'number' || schema?.format === 'guid');
-                        if (extendedKey && (definitions.size !== 1 || capture.uniqueConstraint!.eventDefinitions.length !== 1 ||
+                        if (extendedKey && (applicable.size !== 1 || capture.uniqueConstraint!.eventDefinitions.length !== 1 ||
                             removedWith.some(id => id !== undefined))) {
                             throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
                                 'Guid and numeric keys require one isolated definition covering one event type without removers; shared definitions and removal combinations are not fixture-backed.');

package/testing/InProcessConstraints.ts

@@ -69,7 +69,8 @@ export class InProcessConstraints {
     private readonly _propertyRemovalTypes = new Set<string>();
 
     constructor(private readonly _definitions: ReadonlyMap<string, ConstraintCapture>,
-        private readonly _schemas: ReadonlyMap<string, JsonSchema> = new Map()) {
+        private readonly _schemas: ReadonlyMap<string, JsonSchema> = new Map(),
+        private readonly _inapplicable: ReadonlySet<string> = new Set()) {
         const coveredTypes = new Map<string, string>();
         const removalOwners = new Map<string, string>();
         for (const [name, capture] of _definitions) {
@@ -161,6 +162,9 @@ export class InProcessConstraints {
 
     hasRemovalType(eventTypeId: string): boolean { return this._removalTypes.has(eventTypeId); }
 
+    /** Whether a named definition is scoped to event sequences other than the scenario's, so it takes no part. */
+    isInapplicable(name: string): boolean { return this._inapplicable.has(name); }
+
     isConstrainedProperty(eventTypeId: string, property: string): boolean {
         return this._constrainedProperties.get(eventTypeId)?.has(property) ?? false;
     }

package/testing/InProcessEventSequence.ts

@@ -110,7 +110,8 @@ export class InProcessEventSequence implements IEventSequence {
             if (eventType.generation.value !== 1 || eventType.tombstone) {
                 throw this.unsupported('artifacts.eventTypes', type.name, 'Only generation 1, non-tombstone events are proven.');
             }
-            if (options.constraints !== 'disabled' && getRemovedConstraintNames(type).length &&
+            if (options.constraints !== 'disabled' &&
+                getRemovedConstraintNames(type).some(name => !this._constraints?.isInapplicable(name)) &&
                 !this._constraints?.hasRemovalType(eventType.id.value)) {
                 throw this.unsupported('artifacts.eventTypes.constraints', type.name, 'Constraint removal is not fixture-backed.');
             }

package/testing/for_EventScenario/when_appending_event_sequence_constraints/event_sequence_scenario_behaviors.fixture.ts

@@ -0,0 +1,101 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { readFileSync } from 'node:fs';
+import { chai, describe, it, vi, type Assertion } from 'vitest';
+import type { Constructor } from '@cratis/fundamentals';
+import { getEventTypeMetadata } from '../../../events/eventTypeDecorator.js';
+import { compileConstraints } from '../../../events/constraints/Constraints.js';
+import { EventScenario } from '../../index.js';
+import { InProcessConstraints } from '../../InProcessConstraints.js';
+
+chai.should();
+function should(value: unknown): Assertion { return (value as { should: Assertion }).should; }
+
+type Entry = { source: string; type: string; value: string };
+type Definition = { kind: string; name: string; events?: Array<{ type: string; properties: string[] }>; eventTypes?: string[];
+    ignoreCasing?: boolean; removedWithEventTypeIds: string[]; message: string; eventSequences: string[] };
+type History = { sequence: string; source: string; sourceType?: string; streamType?: string; streamId?: string;
+    type: string; content: Record<string, unknown>; hash?: string };
+type Outcome = { success: boolean; sequences: string[]; errors: string[];
+    wireViolations: Array<{ EventTypeId: string; SequenceNumber: string; ConstraintType: number; ConstraintName: string; Message: string; Details: Record<string, string> }>;
+    violations: Array<{ id: string; message: string; details: Record<string, string> }>; history: History[]; next: string };
+type SequenceCase = { name: string; kind: string; eventSchemas: Record<string, { eventTypeId: string; properties: Record<string, string> }>;
+    constraintDefinitions: Definition[]; isolatedConstraintOperations: Array<{ mode: string; events: Entry[] }> };
+type Fixture = { eventSequenceCases: SequenceCase[]; expected: { cases: Array<{ name: string; result: { outcomes: Outcome[] } }> } };
+
+/**
+ * Replays constraints-event-sequences.json: a definition applying to the event log behaves as unscoped, and one
+ * applying only to other event sequences is neither validated nor indexed on the scenario's event log.
+ * @param types - Event constructors by fixture alias.
+ * @param constraints - Selects the constraint classes for a case name.
+ */
+export function eventSequenceScenarioBehaviors(
+    types: Record<string, new (value: string) => object>,
+    constraints: (caseName: string) => Constructor[]
+): void {
+    const fixture = JSON.parse(readFileSync(new URL('../../fixtures/constraints-event-sequences.json', import.meta.url), 'utf8')) as Fixture;
+    const historyOf = (scenario: EventScenario): History[] => scenario.appendedEvents.map(event => ({
+        sequence: event.context.sequenceNumber.toString(), source: event.context.eventSourceId,
+        sourceType: event.context.eventSourceType, streamType: event.context.eventStreamType, streamId: event.context.eventStreamId,
+        type: event.eventType.id.value, content: event.content, hash: event.context.hash
+    }));
+    const aliases = Object.fromEntries(Object.entries(types).map(([alias, type]) => [getEventTypeMetadata(type)!.eventType.id.value, alias]));
+
+    it('should retain every event sequence case', () => {
+        should(fixture.eventSequenceCases.map(test => test.name)).deep.equal([
+            'property-event-log', 'property-event-log-and-outbox', 'property-outbox',
+            'cycle-event-log', 'cycle-outbox', 'once-event-log', 'once-outbox'
+        ]);
+        should(fixture.expected.cases.map(test => test.name)).deep.equal(fixture.eventSequenceCases.map(test => test.name));
+    });
+
+    for (const [caseIndex, test] of fixture.eventSequenceCases.entries()) {
+        describe(`with ${test.name}`, () => {
+            it('should match the installed definitions and kernel violations, history and next sequence', async () => {
+                const selected = Object.keys(test.eventSchemas).map(alias => types[alias]);
+                const selectedConstraints = constraints(test.name);
+                const compiled = compileConstraints({ eventTypes: selected, constraints: selectedConstraints });
+                should([...compiled].map(([name, capture]) => ({
+                    kind: capture.uniqueConstraint ? 'uniqueProperty' : 'uniqueEventType', name,
+                    ...(capture.uniqueConstraint ? {
+                        events: capture.uniqueConstraint.eventDefinitions.map(entry => ({ type: aliases[entry.eventTypeId], properties: entry.properties })),
+                        ignoreCasing: capture.uniqueConstraint.ignoreCasing
+                    } : { eventTypes: (capture.uniqueEventType!.eventTypeIds ?? [capture.uniqueEventType!.eventTypeId]).map(id => aliases[id]) }),
+                    removedWithEventTypeIds: (capture.uniqueConstraint?.removedWithEventTypeIds ?? capture.uniqueEventType?.removedWithEventTypeIds ?? []).map(id => aliases[id]),
+                    message: capture.uniqueConstraint?.message ?? capture.uniqueEventType?.message ?? '',
+                    eventSequences: capture.eventSequences ?? []
+                }))).deep.equal(test.constraintDefinitions);
+                const scenario = new EventScenario({ artifacts: { eventTypes: selected, constraints: selectedConstraints } });
+                const validate = vi.spyOn(InProcessConstraints.prototype, 'validate');
+                const expected = fixture.expected.cases[caseIndex].result.outcomes;
+                should(expected.length).equal(test.isolatedConstraintOperations.length);
+                try {
+                    for (const [index, operation] of test.isolatedConstraintOperations.entries()) {
+                        const before = historyOf(scenario);
+                        const entries = operation.events.map(entry => ({ eventSourceId: entry.source, event: new types[entry.type](entry.value) }));
+                        const results = operation.mode === 'single'
+                            ? [await scenario.append(entries[0].eventSourceId, entries[0].event)]
+                            : await scenario.appendMany(entries);
+                        const outcome = expected[index];
+                        const raw = validate.mock.results.at(-1)!.value as ReturnType<InProcessConstraints['validate']>;
+                        should(raw.map(({ SequenceNumber, ...violation }) => ({ ...violation, SequenceNumber: SequenceNumber.toString() })))
+                            .deep.equal(outcome.wireViolations);
+                        for (const [position, result] of results.entries()) {
+                            should(result.isSuccess).equal(outcome.success);
+                            should(result.sequenceNumber.value.toString()).equal(outcome.success ? outcome.sequences[position] : '0');
+                            should(result.constraintViolations.map(violation => ({ id: violation.constraintId, message: violation.message, details: violation.details })))
+                                .deep.equal(outcome.violations);
+                            should(result.errors.map(error => error.message)).deep.equal(outcome.errors);
+                        }
+                        if (!outcome.success) should(historyOf(scenario)).deep.equal(before);
+                        should(historyOf(scenario)).deep.equal(outcome.history);
+                        should((await scenario.eventLog.getNextSequenceNumber()).value.toString()).equal(outcome.next);
+                    }
+                } finally {
+                    validate.mockRestore();
+                }
+            });
+        });
+    }
+}

package/testing/for_EventScenario/when_appending_event_sequence_constraints/other_sequence_extended_key.legacy.spec.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 { field } from '@cratis/fundamentals';
+import { describe } from 'vitest';
+import { eventType } from '../../../events/eventTypeDecorator.js';
+import { constraint } from '../../../events/constraints/constraint.js';
+import type { IConstraintBuilder } from '../../../events/constraints/IConstraintBuilder.js';
+import { otherSequenceExtendedKeyBehaviors } from './other_sequence_extended_key_behaviors.fixture.js';
+
+@eventType('OracleOtherSequenceNumber')
+class NumberClaimed { @field(Number) key = 1; }
+@eventType('OracleOtherSequenceOutbox')
+class OutboxClaimed { @field(String) label = 'x'; }
+
+@constraint('OracleOtherSequenceNumberKey')
+class NumberKey {
+    define(builder: IConstraintBuilder) { builder.forEventLog().unique(key => key.on(NumberClaimed, event => event.key)); }
+}
+@constraint('OracleOtherSequenceOutboxKey')
+class OutboxKey {
+    define(builder: IConstraintBuilder) { builder.forEventSequences('outbox').unique(key => key.on(OutboxClaimed, event => event.label)); }
+}
+
+describe('when appending extended keys beside other event sequence constraints with  decorators', () => {
+    otherSequenceExtendedKeyBehaviors(NumberClaimed, OutboxClaimed, [NumberKey, OutboxKey]);
+});