From Every Event

Use an every-event mapping when a read model property should update whenever any event in the projection is processed. This is usually audit metadata such as the last modification time, the latest event sequence number, or the correlation id of the operation that last touched the read model.

Every-event mappings are different from event-specific mappings. A set mapping applies only when its event type is processed. An every-event mapping applies after any event that belongs to the projection.

Map Event Context

Event context is the most common source for every-event mappings because every event has the same context shape. This keeps audit fields independent from the event payloads.

C#

Update an audit timestamp from every event

using Cratis.Chronicle.Events;
using Cratis.Chronicle.Keys;
using Cratis.Chronicle.Projections.ModelBound;

[EventType]
public record InventoryProductRegisteredForEvery(string ProductName);

[EventType]
public record InventoryItemsAdjustedForEvery(int Quantity);

[FromEvent<InventoryProductRegisteredForEvery>]
[FromEvent<InventoryItemsAdjustedForEvery>]
public record InventoryStatusFromEvery(
    [Key] Guid Id,
    string ProductName,
    [FromEvery(contextProperty: nameof(EventContext.Occurred))]
    DateTimeOffset LastUpdated);

View C# snippet source on GitHub

Kotlin

Update an audit timestamp from every event

import io.cratis.chronicle.events.EventType
import io.cratis.chronicle.projections.FromEvent
import io.cratis.chronicle.projections.FromEvery
import io.cratis.chronicle.readModels.ReadModel

@EventType
data class InventoryProductRegisteredForEvery(val productName: String)

@EventType
data class InventoryItemsAdjustedForEvery(val quantity: Int)

@ReadModel
@FromEvent(InventoryProductRegisteredForEvery::class)
@FromEvent(InventoryItemsAdjustedForEvery::class)
data class InventoryStatusFromEvery(
    val productName: String = "",

    @FromEvery(contextProperty = "occurred")
    val lastUpdated: String = ""
)

View Kotlin snippet source on GitHub

Java

Update an audit timestamp from every event

import io.cratis.chronicle.events.EventType;
import io.cratis.chronicle.projections.FromEvent;
import io.cratis.chronicle.projections.FromEvery;
import io.cratis.chronicle.readModels.ReadModel;

@EventType
record InventoryProductRegisteredForEvery(String productName) {}

@EventType
record InventoryItemsAdjustedForEvery(int quantity) {}

@ReadModel
@FromEvent(eventType = InventoryProductRegisteredForEvery.class)
@FromEvent(eventType = InventoryItemsAdjustedForEvery.class)
class InventoryStatusFromEvery {
    public String productName = "";

    @FromEvery(contextProperty = "occurred")
    public String lastUpdated = "";
}

View Java snippet source on GitHub

Elixir

Update an audit timestamp from every event

defmodule MyApp.Events.InventoryProductRegisteredForEvery do
  use Chronicle.Events.EventType, id: "inventory-product-registered-for-every-v1"

  defstruct [:product_name]
end

defmodule MyApp.Events.InventoryItemsAdjustedForEvery do
  use Chronicle.Events.EventType, id: "inventory-items-adjusted-for-every-v1"

  defstruct [:quantity]
end

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

  alias MyApp.Events.{InventoryItemsAdjustedForEvery, InventoryProductRegisteredForEvery}

  defstruct [:id, :product_name, :last_updated]

  from InventoryProductRegisteredForEvery,
    set: [
      id: :event_source_id,
      product_name: :product_name
    ]

  from InventoryItemsAdjustedForEvery

  from_every set: [last_updated: :occurred]
end

View Elixir snippet source on GitHub

TypeScript

Update an audit timestamp from every event

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

@eventType()
export class InventoryProductRegisteredForEvery {
    @field(String) readonly productName: string;

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

@eventType()
export class InventoryItemsAdjustedForEvery {
    @field(Number) readonly quantity: number;

    constructor(quantity: number) {
        this.quantity = quantity;
    }
}

@fromEvent(InventoryProductRegisteredForEvery)
@fromEvent(InventoryItemsAdjustedForEvery)
export class InventoryStatusFromEvery {
    @field(String) productName = '';

    @fromEvery(undefined, 'occurred')
    lastUpdated = new Date();
}

View TypeScript snippet source on GitHub

You can map multiple context fields when the read model needs a small audit trail.

C#

Track audit metadata from every event

using Cratis.Chronicle.Events;
using Cratis.Chronicle.Keys;
using Cratis.Chronicle.Projections.ModelBound;

[EventType]
public record AuditableInventoryChangedForEvery(string Reason);

[FromEvent<AuditableInventoryChangedForEvery>]
public record AuditableInventoryStatusFromEvery(
    [Key] Guid Id,
    [FromEvery(contextProperty: nameof(EventContext.Occurred))]
    DateTimeOffset LastModified,
    [FromEvery(contextProperty: nameof(EventContext.SequenceNumber))]
    EventSequenceNumber LastEventSequence,
    [FromEvery(contextProperty: nameof(EventContext.CorrelationId))]
    string LastCorrelationId);

View C# snippet source on GitHub

Kotlin

Track audit metadata from every event

import io.cratis.chronicle.events.EventType
import io.cratis.chronicle.projections.FromEvent
import io.cratis.chronicle.projections.FromEvery
import io.cratis.chronicle.readModels.ReadModel

@EventType
data class AuditableInventoryChangedForEvery(val reason: String)

@ReadModel
@FromEvent(AuditableInventoryChangedForEvery::class)
data class AuditableInventoryStatusFromEvery(
    @FromEvery(contextProperty = "occurred")
    val lastModified: String = "",

    @FromEvery(contextProperty = "sequenceNumber")
    val lastEventSequence: String = "",

    @FromEvery(contextProperty = "correlationId")
    val lastCorrelationId: String = ""
)

View Kotlin snippet source on GitHub

Java

Track audit metadata from every event

import io.cratis.chronicle.events.EventType;
import io.cratis.chronicle.projections.FromEvent;
import io.cratis.chronicle.projections.FromEvery;
import io.cratis.chronicle.readModels.ReadModel;

@EventType
record AuditableInventoryChangedForEvery(String reason) {}

@ReadModel
@FromEvent(eventType = AuditableInventoryChangedForEvery.class)
class AuditableInventoryStatusFromEvery {
    @FromEvery(contextProperty = "occurred")
    public String lastModified = "";

    @FromEvery(contextProperty = "sequenceNumber")
    public String lastEventSequence = "";

    @FromEvery(contextProperty = "correlationId")
    public String lastCorrelationId = "";
}

View Java snippet source on GitHub

Elixir

Track audit metadata from every event

defmodule MyApp.Events.AuditableInventoryChangedForEvery do
  use Chronicle.Events.EventType, id: "auditable-inventory-changed-for-every-v1"

  defstruct [:reason]
end

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

  alias MyApp.Events.AuditableInventoryChangedForEvery

  defstruct [:id, :last_modified, :last_event_sequence, :last_correlation_id]

  from AuditableInventoryChangedForEvery,
    set: [id: :event_source_id]

  from_every set: [
    last_modified: :occurred,
    last_event_sequence: "$context.sequenceNumber",
    last_correlation_id: "$context.correlationId"
  ]
end

View Elixir snippet source on GitHub

TypeScript

Track audit metadata from every event

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

@eventType()
export class AuditableInventoryChangedForEvery {
    @field(String) readonly reason: string;

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

@fromEvent(AuditableInventoryChangedForEvery)
export class AuditableInventoryStatusFromEvery {
    @fromEvery(undefined, 'occurred')
    lastModified = new Date();

    @fromEvery(undefined, 'sequenceNumber')
    @field(Number) lastEventSequence = 0n;

    @fromEvery(undefined, 'correlationId')
    lastCorrelationId = '';
}

View TypeScript snippet source on GitHub

Map Event Payload Properties

Every-event mappings can also read from event payload properties. Use this only when each event in the projection carries the same property name and compatible value type.

C#

Read a shared event property from every event

using Cratis.Chronicle.Events;
using Cratis.Chronicle.Keys;
using Cratis.Chronicle.Projections.ModelBound;

public enum OrderStateFromEvery
{
    New,
    Confirmed,
    Shipped
}

[EventType]
public record OrderConfirmedForEvery(OrderStateFromEvery Status);

[EventType]
public record OrderShippedForEvery(OrderStateFromEvery Status);

[FromEvent<OrderConfirmedForEvery>]
[FromEvent<OrderShippedForEvery>]
public record OrderStatusFromEvery(
    [Key] Guid Id,
    [FromEvery(property: nameof(OrderConfirmedForEvery.Status))]
    OrderStateFromEvery CurrentStatus);

View C# snippet source on GitHub

Kotlin

Read a shared event property from every event

import io.cratis.chronicle.events.EventType
import io.cratis.chronicle.projections.FromEvent
import io.cratis.chronicle.projections.FromEvery
import io.cratis.chronicle.readModels.ReadModel

enum class OrderStateFromEvery {
    New,
    Confirmed,
    Shipped
}

@EventType
data class OrderConfirmedForEvery(val status: OrderStateFromEvery)

@EventType
data class OrderShippedForEvery(val status: OrderStateFromEvery)

@ReadModel
@FromEvent(OrderConfirmedForEvery::class)
@FromEvent(OrderShippedForEvery::class)
data class OrderStatusFromEvery(
    @FromEvery(property = "status")
    val currentStatus: OrderStateFromEvery = OrderStateFromEvery.New
)

View Kotlin snippet source on GitHub

Java

Read a shared event property from every event

import io.cratis.chronicle.events.EventType;
import io.cratis.chronicle.projections.FromEvent;
import io.cratis.chronicle.projections.FromEvery;
import io.cratis.chronicle.readModels.ReadModel;

enum OrderStateFromEvery {
    New,
    Confirmed,
    Shipped
}

@EventType
record OrderConfirmedForEvery(OrderStateFromEvery status) {}

@EventType
record OrderShippedForEvery(OrderStateFromEvery status) {}

@ReadModel
@FromEvent(eventType = OrderConfirmedForEvery.class)
@FromEvent(eventType = OrderShippedForEvery.class)
class OrderStatusFromEvery {
    @FromEvery(property = "status")
    public OrderStateFromEvery currentStatus = OrderStateFromEvery.New;
}

View Java snippet source on GitHub

Elixir

Read a shared event property from every event

defmodule MyApp.Events.OrderConfirmedForEvery do
  use Chronicle.Events.EventType, id: "order-confirmed-for-every-v1"

  defstruct [:status]
end

defmodule MyApp.Events.OrderShippedForEvery do
  use Chronicle.Events.EventType, id: "order-shipped-for-every-v1"

  defstruct [:status]
end

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

  alias MyApp.Events.{OrderConfirmedForEvery, OrderShippedForEvery}

  defstruct [:id, :current_status]

  from OrderConfirmedForEvery,
    set: [id: :event_source_id]

  from OrderShippedForEvery

  from_every set: [current_status: :status]
end

View Elixir snippet source on GitHub

TypeScript

Read a shared event property from every event

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

enum OrderStateFromEvery {
    New = 'New',
    Confirmed = 'Confirmed',
    Shipped = 'Shipped'
}

@eventType()
export class OrderConfirmedForEvery {
    @field(String) readonly status: OrderStateFromEvery;

    constructor(status: OrderStateFromEvery) {
        this.status = status;
    }
}

@eventType()
export class OrderShippedForEvery {
    @field(String) readonly status: OrderStateFromEvery;

    constructor(status: OrderStateFromEvery) {
        this.status = status;
    }
}

@fromEvent(OrderConfirmedForEvery)
@fromEvent(OrderShippedForEvery)
export class OrderStatusFromEvery {
    @fromEvery('status')
    currentStatus = OrderStateFromEvery.New;
}

View TypeScript snippet source on GitHub

If a client supports convention-based property mapping, omitting the source property uses the read model property name.

C#

Use the read model property name by convention

using Cratis.Chronicle.Events;
using Cratis.Chronicle.Keys;
using Cratis.Chronicle.Projections.ModelBound;

[EventType]
public record ProductRenamedForEveryConvention(string Name, int Version);

[EventType]
public record ProductPriceChangedForEveryConvention(decimal Price, int Version);

[FromEvent<ProductRenamedForEveryConvention>]
[FromEvent<ProductPriceChangedForEveryConvention>]
public record ProductVersionFromEveryConvention(
    [Key] Guid Id,
    string Name,
    decimal Price,
    [FromEvery]
    int Version);

View C# snippet source on GitHub

Kotlin

Use the read model property name by convention

import io.cratis.chronicle.events.EventType
import io.cratis.chronicle.projections.FromEvent
import io.cratis.chronicle.projections.FromEvery
import io.cratis.chronicle.readModels.ReadModel

@EventType
data class ProductRenamedForEveryConvention(val name: String, val version: Int)

@EventType
data class ProductPriceChangedForEveryConvention(val price: Double, val version: Int)

@ReadModel
@FromEvent(ProductRenamedForEveryConvention::class)
@FromEvent(ProductPriceChangedForEveryConvention::class)
data class ProductVersionFromEveryConvention(
    val name: String = "",
    val price: Double = 0.0,

    @FromEvery
    val version: Int = 0
)

View Kotlin snippet source on GitHub

Java

Use the read model property name by convention

import io.cratis.chronicle.events.EventType;
import io.cratis.chronicle.projections.FromEvent;
import io.cratis.chronicle.projections.FromEvery;
import io.cratis.chronicle.readModels.ReadModel;

@EventType
record ProductRenamedForEveryConvention(String name, int version) {}

@EventType
record ProductPriceChangedForEveryConvention(double price, int version) {}

@ReadModel
@FromEvent(eventType = ProductRenamedForEveryConvention.class)
@FromEvent(eventType = ProductPriceChangedForEveryConvention.class)
class ProductVersionFromEveryConvention {
    public String name = "";
    public double price = 0.0;

    @FromEvery
    public int version = 0;
}

View Java snippet source on GitHub

Elixir

defmodule MyApp.Events.ProductRenamedForEveryConvention do
  use Chronicle.Events.EventType, id: "product-renamed-for-every-convention"

  defstruct name: "", version: 0
end

defmodule MyApp.Events.ProductPriceChangedForEveryConvention do
  use Chronicle.Events.EventType, id: "product-price-changed-for-every-convention"

  defstruct price: 0.0, version: 0
end

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

  defstruct id: nil, name: nil, price: 0.0, version: 0

  from MyApp.Events.ProductRenamedForEveryConvention,
    set: [id: :event_source_id]

  from MyApp.Events.ProductPriceChangedForEveryConvention

  from_every set: [version: :version]
end

View Elixir snippet source on GitHub

TypeScript

Use the read model property name by convention

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

@eventType()
export class ProductRenamedForEveryConvention {
    @field(String) readonly name: string;
    @field(Number) readonly version: number;

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

@eventType()
export class ProductPriceChangedForEveryConvention {
    @field(Number) readonly price: number;
    @field(Number) readonly version: number;

    constructor(price: number, version: number) {
        this.price = price;
        this.version = version;
    }
}

@fromEvent(ProductRenamedForEveryConvention)
@fromEvent(ProductPriceChangedForEveryConvention)
export class ProductVersionFromEveryConvention {
    @field(String) name = '';
    @field(Number) price = 0;

    @fromEvery()
    version = 0;
}

View TypeScript snippet source on GitHub

Combine With Event-Specific Mappings

When an event is processed, Chronicle applies the event-specific mappings for that event and the every-event mappings for the projection. This lets the read model update business fields and audit metadata in the same event pass.

C#

Combine specific mappings with every-event metadata

using Cratis.Chronicle.Events;
using Cratis.Chronicle.Keys;
using Cratis.Chronicle.Projections.ModelBound;

[EventType]
public record UserRegisteredForEvery(string Name, string Email);

[EventType]
public record UserNameChangedForEvery(string NewName);

[EventType]
public record UserEmailChangedForEvery(string NewEmail);

[FromEvent<UserRegisteredForEvery>]
[FromEvent<UserNameChangedForEvery>]
[FromEvent<UserEmailChangedForEvery>]
public record UserProfileFromEvery(
    [Key] Guid Id,
    [SetFrom<UserRegisteredForEvery>(nameof(UserRegisteredForEvery.Name))]
    [SetFrom<UserNameChangedForEvery>(nameof(UserNameChangedForEvery.NewName))]
    string Name,
    [SetFrom<UserRegisteredForEvery>(nameof(UserRegisteredForEvery.Email))]
    [SetFrom<UserEmailChangedForEvery>(nameof(UserEmailChangedForEvery.NewEmail))]
    string Email,
    [FromEvery(contextProperty: nameof(EventContext.Occurred))]
    DateTimeOffset LastUpdated);

View C# snippet source on GitHub

Kotlin

Combine specific mappings with every-event metadata

import io.cratis.chronicle.events.EventType
import io.cratis.chronicle.projections.FromEvent
import io.cratis.chronicle.projections.FromEvery
import io.cratis.chronicle.projections.SetFrom
import io.cratis.chronicle.readModels.ReadModel

@EventType
data class UserRegisteredForEvery(val name: String, val email: String)

@EventType
data class UserNameChangedForEvery(val newName: String)

@EventType
data class UserEmailChangedForEvery(val newEmail: String)

@ReadModel
@FromEvent(UserRegisteredForEvery::class)
@FromEvent(UserNameChangedForEvery::class)
@FromEvent(UserEmailChangedForEvery::class)
data class UserProfileFromEvery(
    @SetFrom("name", UserRegisteredForEvery::class)
    @SetFrom("newName", UserNameChangedForEvery::class)
    val name: String = "",

    @SetFrom("email", UserRegisteredForEvery::class)
    @SetFrom("newEmail", UserEmailChangedForEvery::class)
    val email: String = "",

    @FromEvery(contextProperty = "occurred")
    val lastUpdated: String = ""
)

View Kotlin snippet source on GitHub

Java

Combine specific mappings with every-event metadata

import io.cratis.chronicle.events.EventType;
import io.cratis.chronicle.projections.FromEvent;
import io.cratis.chronicle.projections.FromEvery;
import io.cratis.chronicle.projections.SetFrom;
import io.cratis.chronicle.readModels.ReadModel;

@EventType
record UserRegisteredForEvery(String name, String email) {}

@EventType
record UserNameChangedForEvery(String newName) {}

@EventType
record UserEmailChangedForEvery(String newEmail) {}

@ReadModel
@FromEvent(eventType = UserRegisteredForEvery.class)
@FromEvent(eventType = UserNameChangedForEvery.class)
@FromEvent(eventType = UserEmailChangedForEvery.class)
class UserProfileFromEvery {
    @SetFrom(propertyPath = "name", eventType = UserRegisteredForEvery.class)
    @SetFrom(propertyPath = "newName", eventType = UserNameChangedForEvery.class)
    public String name = "";

    @SetFrom(propertyPath = "email", eventType = UserRegisteredForEvery.class)
    @SetFrom(propertyPath = "newEmail", eventType = UserEmailChangedForEvery.class)
    public String email = "";

    @FromEvery(contextProperty = "occurred")
    public String lastUpdated = "";
}

View Java snippet source on GitHub

Elixir

Combine specific mappings with every-event metadata

defmodule MyApp.Events.UserRegisteredForEvery do
  use Chronicle.Events.EventType, id: "user-registered-for-every-v1"

  defstruct [:name, :email]
end

defmodule MyApp.Events.UserNameChangedForEvery do
  use Chronicle.Events.EventType, id: "user-name-changed-for-every-v1"

  defstruct [:new_name]
end

defmodule MyApp.Events.UserEmailChangedForEvery do
  use Chronicle.Events.EventType, id: "user-email-changed-for-every-v1"

  defstruct [:new_email]
end

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

  alias MyApp.Events.{UserEmailChangedForEvery, UserNameChangedForEvery, UserRegisteredForEvery}

  defstruct [:id, :name, :email, :last_updated]

  from UserRegisteredForEvery,
    set: [
      id: :event_source_id,
      name: :name,
      email: :email
    ]

  from UserNameChangedForEvery,
    set: [name: :new_name]

  from UserEmailChangedForEvery,
    set: [email: :new_email]

  from_every set: [last_updated: :occurred]
end

View Elixir snippet source on GitHub

TypeScript

Combine specific mappings with every-event metadata

import { eventType, fromEvent, fromEvery, setFrom } from '@cratis/chronicle';
import { field } from '@cratis/fundamentals';

@eventType()
export class UserRegisteredForEvery {
    @field(String) readonly name: string;
    @field(String) readonly email: string;

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

@eventType()
export class UserNameChangedForEvery {
    @field(String) readonly newName: string;

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

@eventType()
export class UserEmailChangedForEvery {
    @field(String) readonly newEmail: string;

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

@fromEvent(UserRegisteredForEvery)
@fromEvent(UserNameChangedForEvery)
@fromEvent(UserEmailChangedForEvery)
export class UserProfileFromEvery {
    @setFrom(UserRegisteredForEvery, 'name')
    @setFrom(UserNameChangedForEvery, 'newName')
    name = '';

    @setFrom(UserRegisteredForEvery, 'email')
    @setFrom(UserEmailChangedForEvery, 'newEmail')
    email = '';

    @fromEvery(undefined, 'occurred')
    lastUpdated = new Date();
}

View TypeScript snippet source on GitHub

For example, when the name-change event in the examples above is processed:

1. The name mapping updates the read model’s name.
2. The every-event mapping updates the last-modified field from the event context.

Declarative Equivalent

Every-event mappings are part of the projection definition Chronicle receives. Clients that expose both model-bound and standalone projection definitions send the same kind of every-event definition to Chronicle.

C#

Declarative projection with every-event metadata

using Cratis.Chronicle.Events;
using Cratis.Chronicle.Keys;
using Cratis.Chronicle.Projections;

[EventType]
public record InventoryRegisteredDeclarativeForEvery(string ProductName);

[EventType]
public record InventoryAdjustedDeclarativeForEvery(int Quantity);

public record InventoryStatusDeclarativeFromEvery(
    [property: Key] Guid Id,
    string ProductName,
    DateTimeOffset LastUpdated);

public class InventoryStatusDeclarativeProjection : IProjectionFor<InventoryStatusDeclarativeFromEvery>
{
    public void Define(IProjectionBuilderFor<InventoryStatusDeclarativeFromEvery> builder) => builder
        .From<InventoryRegisteredDeclarativeForEvery>()
        .From<InventoryAdjustedDeclarativeForEvery>()
        .FromEvery(_ => _
            .Set(m => m.LastUpdated)
            .ToEventContextProperty(c => c.Occurred));
}

View C# snippet source on GitHub

Kotlin

Declarative projection with every-event metadata

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

@EventType
data class InventoryRegisteredDeclarativeForEvery(val productName: String)

@EventType
data class InventoryAdjustedDeclarativeForEvery(val quantity: Int)

data class InventoryStatusDeclarativeFromEvery(
    val productName: String = "",
    val lastUpdated: String = ""
)

class InventoryStatusDeclarativeProjection : IProjectionFor<InventoryStatusDeclarativeFromEvery> {
    override fun define(builder: IProjectionBuilderFor<InventoryStatusDeclarativeFromEvery>) {
        builder
            .from(InventoryRegisteredDeclarativeForEvery::class)
            .from(InventoryAdjustedDeclarativeForEvery::class)
            .fromEvery { it ->
                it.set(InventoryStatusDeclarativeFromEvery::lastUpdated).toEventContextProperty("occurred")
            }
    }
}

View Kotlin snippet source on GitHub

Java

Declarative projection with every-event metadata

import io.cratis.chronicle.events.EventType;
import io.cratis.chronicle.projections.IProjectionBuilderFor;
import io.cratis.chronicle.projections.IProjectionFor;

@EventType
record InventoryRegisteredDeclarativeForEvery(String productName) {
}

@EventType
record InventoryAdjustedDeclarativeForEvery(int quantity) {
}

class InventoryStatusDeclarativeFromEvery {
    public String productName = "";
    public String lastUpdated = "";
}

class InventoryStatusDeclarativeProjection implements IProjectionFor<InventoryStatusDeclarativeFromEvery> {
    @Override
    public void define(IProjectionBuilderFor<InventoryStatusDeclarativeFromEvery> builder) {
        builder
            .from(InventoryRegisteredDeclarativeForEvery.class)
            .from(InventoryAdjustedDeclarativeForEvery.class)
            .fromEvery(every -> {
                every.set("lastUpdated").toEventContextProperty("occurred");
            });
    }
}

View Java snippet source on GitHub

Elixir

Declarative projection with every-event metadata

defmodule MyApp.Events.InventoryRegisteredDeclarativeForEvery do
  use Chronicle.Events.EventType, id: "inventory-registered-declarative-for-every-v1"

  defstruct [:product_name]
end

defmodule MyApp.Events.InventoryAdjustedDeclarativeForEvery do
  use Chronicle.Events.EventType, id: "inventory-adjusted-declarative-for-every-v1"

  defstruct [:quantity]
end

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

  defstruct [:id, :product_name, :last_updated]
end

defmodule MyApp.Projections.InventoryStatusDeclarativeProjection do
  use Chronicle.Projections.Projection, model: MyApp.ReadModels.InventoryStatusDeclarativeFromEvery

  alias MyApp.Events.{InventoryAdjustedDeclarativeForEvery, InventoryRegisteredDeclarativeForEvery}

  from InventoryRegisteredDeclarativeForEvery,
    set: [
      id: :event_source_id,
      product_name: :product_name
    ]

  from InventoryAdjustedDeclarativeForEvery

  from_every set: [last_updated: :occurred]
end

View Elixir snippet source on GitHub

TypeScript

Declarative projection with every-event metadata

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

@eventType()
export class InventoryRegisteredDeclarativeForEvery {
    @field(String) readonly productName: string;

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

@eventType()
export class InventoryAdjustedDeclarativeForEvery {
    @field(Number) readonly quantity: number;

    constructor(quantity: number) {
        this.quantity = quantity;
    }
}

export class InventoryStatusDeclarativeFromEvery {
    productName = '';
    lastUpdated = new Date();
}

@projection('', InventoryStatusDeclarativeFromEvery)
export class InventoryStatusDeclarativeProjection implements IProjectionFor<InventoryStatusDeclarativeFromEvery> {
    define(builder: IProjectionBuilderFor<InventoryStatusDeclarativeFromEvery>): void {
        builder
            .from(InventoryRegisteredDeclarativeForEvery)
            .from(InventoryAdjustedDeclarativeForEvery)
            .fromEvery(_ => _
                .set(m => m.lastUpdated)
                .toEventContextProperty('occurred'));
    }
}

View TypeScript snippet source on GitHub

Use Cases

Use case	Typical source
Last modification time	Event context occurrence time
Last event sequence	Event context sequence number
Last operation id	Event context correlation id
Current status shared by all events	Event payload property

Prefer context properties for audit metadata. Use payload properties only when the event contracts are intentionally consistent. If a property should update only for selected event types, use an event-specific mapping instead.

Child Events

The kernel now honors child inclusion in every-event mappings. In .NET, [FromEvery] includes events handled only by child projections, including nested child collections. A child’s event updates the containing parent’s audit fields using the child’s resolved parent key; it does not create a root document keyed by the child identifier.

A child-only event advances a root [FromEvery] timestamp even without a root [FromEvent] for that event. In the declaration language, every includes child events by default; use exclude children to keep mappings local to their level.

Put [FromEvery] on a child’s own property to update that child instead. The mapping applies on the child’s creating event as well as later events handled by that child. The same ownership rule applies to nested objects and [FromAll]: a mapping belongs to the object that declares it. Parent fields are never copied into a newly added child.

For compatibility with clients that still put child mappings at the root, see Child and nested properties. A property declared on both root and child cannot be disambiguated until the client is upgraded.

Limitations

• Only one every-event mapping can target the same read model property.
• Payload-property mappings are skipped for events that do not carry the source property. A source property that is present with a null value still maps null.
• The .NET model-bound [FromEvery] attribute has no child-exclusion option today. Use a declarative projection with ExcludeChildProjections() when you need that opt-out.