Declarative constraints

The declarative API lets you define constraints in a dedicated class by implementing IConstraint. Chronicle discovers all IConstraint implementations automatically — no registration is needed.

Client coverage

Kotlin and Java have a real IConstraint/IConstraintBuilder API, but it’s narrower than C#‘s: it has no RemovedWith (releasing a held value), no WithName (custom constraint names), no dynamic message callback, and its on(...) can only target a single event type per unique constraint — no chaining across multiple event types. Tabs on this page that need any of those are marked as gaps for Kotlin/Java rather than silently omitted. Elixir declares a constraint as a standalone module with use Chronicle.Events.Constraint, and also as event-type-attribute macros — see Model-bound constraints — both of which support name-based grouping and releasing.

Use declarative constraints when you need:

• Uniqueness spanning multiple event types with different property names
• A callback to compose dynamic violation messages
• More explicit control over constraint names

Constraint types

Type	Description
Unique property	Enforce that a property value is unique across one or more event types
Unique event type	Enforce that only one event of a specific type can be appended per event source
Closing stream	Close a stream scope when an event of a specific type is appended

Defining a constraint

Implement IConstraint and call the builder in Define:

C#

using Cratis.Chronicle.Events;
using Cratis.Chronicle.Events.Constraints;

[EventType]
public record ConstraintsDeclarativeIndexProjectCreated(string Name);

[EventType]
public record ConstraintsDeclarativeIndexProjectRemoved;

public class ConstraintsDeclarativeIndexUniqueProjectName : IConstraint
{
    public void Define(IConstraintBuilder builder) =>
        builder.Unique(unique =>
            unique
                .On<ConstraintsDeclarativeIndexProjectCreated>(e => e.Name)
                .RemovedWith<ConstraintsDeclarativeIndexProjectRemoved>());
}

View C# snippet source on GitHub

Kotlin

Kotlin does not support this workflow yet.

View Kotlin snippet source on GitHub

Java

Java does not support this workflow yet.

View Java snippet source on GitHub

Elixir

defmodule MyApp.Events.ConstraintsDeclarativeIndexProjectCreated do
  use Chronicle.Events.EventType, id: "constraints-declarative-index-project-created"
  defstruct name: ""
end

defmodule MyApp.Events.ConstraintsDeclarativeIndexProjectRemoved do
  use Chronicle.Events.EventType, id: "constraints-declarative-index-project-removed"
  defstruct []
end

defmodule MyApp.Constraints.ConstraintsDeclarativeIndexUniqueProjectName do
  use Chronicle.Events.Constraint

  unique name: "ConstraintsDeclarativeIndexUniqueProjectName" do
    on MyApp.Events.ConstraintsDeclarativeIndexProjectCreated, [:name]
    removed_with MyApp.Events.ConstraintsDeclarativeIndexProjectRemoved
  end
end

View Elixir snippet source on GitHub

TypeScript

import { constraint, eventType, IConstraint, IConstraintBuilder } from '@cratis/chronicle';
import { field } from '@cratis/fundamentals';

@eventType()
class ConstraintsDeclarativeIndexProjectCreated {
    @field(String) readonly name: string;

    constructor(name: string) {
        this.name = name;
    }
}

@eventType()
class ConstraintsDeclarativeIndexProjectRemoved {
}

@constraint()
class ConstraintsDeclarativeIndexUniqueProjectName implements IConstraint {
    define(builder: IConstraintBuilder): void {
        builder.unique(unique =>
            unique
                .on(ConstraintsDeclarativeIndexProjectCreated, e => e.name)
                .removedWith(ConstraintsDeclarativeIndexProjectRemoved));
    }
}

View TypeScript snippet source on GitHub

Discovery

Chronicle scans all loaded assemblies for types that implement IConstraint and registers them with the Kernel automatically when the client starts. No explicit registration is required.