Simple projection

A projection in Cratis is a way to create read models from events in the event store. The simplest projection automatically maps event properties to read model properties with matching names using the default AutoMap behavior.

Defining a simple projection

A projection implements IProjectionFor<TReadModel> and defines its behavior in the Define method:

C#

using Cratis.Chronicle.Projections;

public class DecSimpleUserProjection : IProjectionFor<DecSimpleUser>
{
    public void Define(IProjectionBuilderFor<DecSimpleUser> builder) => builder
        .From<DecSimpleUserCreated>();
}

Kotlin

import io.cratis.chronicle.projections.IProjectionBuilderFor
import io.cratis.chronicle.projections.IProjectionFor

class DecSimpleUserProjection : IProjectionFor<DecSimpleUser> {
    override fun define(builder: IProjectionBuilderFor<DecSimpleUser>) {
        builder.from(DecSimpleUserCreated::class)
    }
}

Java

Java does not support this workflow yet.

Elixir

defmodule MyApp.Projections.DecSimpleUserProjection do
  use Chronicle.Projections.Projection, model: MyApp.ReadModels.DecSimpleUser

  alias MyApp.Events.DecSimpleUserCreated

  from DecSimpleUserCreated
end

TypeScript

import { IProjectionBuilderFor, IProjectionFor, projection } from '@cratis/chronicle';

@projection()
class DecSimpleUserProjection implements IProjectionFor<DecSimpleUser> {
    define(builder: IProjectionBuilderFor<DecSimpleUser>): void {
        builder.from(DecSimpleUserCreated);
    }
}

This projection:

• Automatically maps properties from UserCreated event to the User read model (AutoMap is enabled by default)
• Uses the event source ID as the key for the read model
• Properties with matching names are automatically mapped

Note: AutoMap is enabled by default at the top level. You don’t need to call .AutoMap() explicitly unless you want to ensure it’s enabled in contexts where it might be disabled. Read more about auto mapping

Read model definition

The read model is a simple record or class representing the projected data:

C#

public record DecSimpleUser(string Name, string Email, DateTimeOffset CreatedAt);

Kotlin

import java.time.OffsetDateTime

data class DecSimpleUser(
    val name: String = "",
    val email: String = "",
    val createdAt: OffsetDateTime? = null
)

Java

Java does not support this workflow yet.

Elixir

defmodule MyApp.ReadModels.DecSimpleUser do
  use Chronicle.ReadModels.ReadModel

  defstruct [:name, :email, :created_at]
end

TypeScript

class DecSimpleUser {
    name = '';
    email = '';
    createdAt = new Date();
}

Event definition

The event should match the read model structure for auto-mapping to work:

C#

using Cratis.Chronicle.Events;

[EventType]
public record DecSimpleUserCreated(string Name, string Email, DateTimeOffset CreatedAt);

Kotlin

import io.cratis.chronicle.events.EventType
import java.time.OffsetDateTime

@EventType(id = "dec-simple-user-created")
data class DecSimpleUserCreated(val name: String, val email: String, val createdAt: OffsetDateTime)

Java

Java does not support this workflow yet.

Elixir

defmodule MyApp.Events.DecSimpleUserCreated do
  use Chronicle.Events.EventType, id: "dec-simple-user-created"

  defstruct [:name, :email, :created_at]
end

TypeScript

class DecSimpleUserCreated {
    name = '';
    email = '';
    createdAt = new Date();
}

How it works

When a UserCreated event is appended to the event log:

1. The projection automatically creates or updates a User read model
2. The event source ID becomes the key for the read model
3. Properties with matching names are copied from event to read model
4. The read model is stored and can be queried

Auto-mapping works when property names and types match between the event and read model. For more control over the mapping, see projection with custom properties.