Events

A Chronicle event is an immutable fact, stored in an event sequence, that records something that happened in your system. Chronicle identifies events by their event type rather than the .NET CLR type, which makes the CLR type a convenient vessel for expressing intent and structure.

using Cratis.Chronicle.Events;

[EventType]
public record EventsIndexEmployeeRegistered(string FirstName, string LastName);

View C# snippet source on GitHub

import io.cratis.chronicle.events.EventType

@EventType
data class EventsIndexTypeEmployeeRegistered(val firstName: String = "", val lastName: String = "")

View Kotlin snippet source on GitHub

import io.cratis.chronicle.events.EventType;

@EventType
record EventsIndexTypeEmployeeRegistered(String firstName, String lastName) {}

View Java snippet source on GitHub

defmodule MyApp.Events.EventsIndexTypeEmployeeRegistered do
  use Chronicle.Events.EventType, id: "events-index-type-employee-registered"

  defstruct [:first_name, :last_name]
end

View Elixir snippet source on GitHub

import { eventType } from '@cratis/chronicle';
import { field } from '@cratis/fundamentals';

@eventType()
class EventsIndexEmployeeRegistered {
    @field(String) firstName: string;
    @field(String) lastName: string;

    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

View TypeScript snippet source on GitHub

Event Sequences and the Event Log

Events live in event sequences, which are ordered, append-only streams. Each event receives a monotonically increasing sequence number that makes it possible to replay events, resume processing, and reason about how far consumers have progressed.

Chronicle includes a specialized event sequence called the event log. It is the default sequence used throughout the system and is exposed through the IEventLog API.

using Cratis.Chronicle.Events;
using Cratis.Chronicle.EventSequences;

public class EventsIndexEmployeesService(IEventLog eventLog)
{
    public Task RegisterEmployee(EventSourceId employeeId, string firstName, string lastName) =>
        eventLog.Append(employeeId, new EventsIndexEmployeeRegistered(firstName, lastName));
}

View C# snippet source on GitHub

import io.cratis.chronicle.IEventStore
import io.cratis.chronicle.events.EventType

@EventType
data class EventsIndexLogEmployeeRegistered(val firstName: String = "", val lastName: String = "")

/**
 * The event log is the default event sequence, exposed through [IEventStore.eventLog].
 */
suspend fun registerEmployee(store: IEventStore, employeeId: String, firstName: String, lastName: String) =
    store.eventLog.append(employeeId, EventsIndexLogEmployeeRegistered(firstName, lastName))

View Kotlin snippet source on GitHub

import io.cratis.chronicle.EventStore;
import io.cratis.chronicle.events.EventType;
import io.cratis.chronicle.eventSequences.AppendResult;

import io.cratis.chronicle.java.EventLogJavaBridge;

@EventType
record EventsIndexLogEmployeeRegistered(String firstName, String lastName) {}

class EventsIndexEventLog {
    // The event log is the default event sequence, exposed through EventStore.getEventLog().
    AppendResult registerEmployee(EventStore store, String employeeId, String firstName, String lastName) {
        return EventLogJavaBridge.append(store.getEventLog(), employeeId, new EventsIndexLogEmployeeRegistered(firstName, lastName), null);
    }
}

View Java snippet source on GitHub

defmodule MyApp.Events.EventsIndexEmployeeRegistered do
  use Chronicle.Events.EventType, id: "events-index-employee-registered"

  defstruct [:first_name, :last_name]
end

defmodule MyApp.EventsIndexEmployeesService do
  alias MyApp.Events.EventsIndexEmployeeRegistered

  def register_employee(employee_id, first_name, last_name) do
    Chronicle.append(employee_id, %EventsIndexEmployeeRegistered{
      first_name: first_name,
      last_name: last_name
    })
  end
end

View Elixir snippet source on GitHub

import { IEventStore } from '@cratis/chronicle';

class EventsIndexEmployeesService {
    constructor(private readonly store: IEventStore) {}

    async registerEmployee(employeeId: string, firstName: string, lastName: string): Promise<void> {
        await this.store.eventLog.append(employeeId, new EventsIndexEmployeeRegistered(firstName, lastName));
    }
}

View TypeScript snippet source on GitHub

Working with Events

Use these topics to append, read, and manage events: