Projection with a Nested Object

Projections can populate a single nullable child object on a read model using the Nested() method. Unlike children collections, which manage an array of items identified by a key, Nested() targets a scalar nullable property that is set from an event and cleared (set to null) by another event.

Client coverage

Declarative nested-object projections (Nested()/ClearWith()) are currently a C#-only mechanism. Kotlin and Java have no fluent nested-object API, TypeScript’s builder throws not implemented yet for this method, and Elixir has no equivalent nested-object embedding pattern. The examples on this page are shown in C# only until nested projection scopes are implemented for the other clients.

Defining a nested object projection

Use the Nested() method with ClearWith<TEvent>() to define the nested relationship:

C#

Nested object projection

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

[EventType]
public record SliceCreatedForNestedBasic(string Name);

[EventType]
public record CommandSetForDeclarativeNestedBasic(string Name, string Schema);

[EventType]
public record CommandClearedForDeclarativeNestedBasic;

public record SliceForNestedBasic(
    string Name,
    CommandItemForNestedBasic? Command);

public record CommandItemForNestedBasic(
    string Name,
    string Schema);

public class SliceProjectionForNestedBasic : IProjectionFor<SliceForNestedBasic>
{
    public void Define(IProjectionBuilderFor<SliceForNestedBasic> builder) => builder
        .From<SliceCreatedForNestedBasic>()
        .Nested(m => m.Command, nested => nested
            .From<CommandSetForDeclarativeNestedBasic>()
            .ClearWith<CommandClearedForDeclarativeNestedBasic>());
}

Kotlin

Nested object projection

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

@EventType
data class SliceCreatedForNestedBasic(val name: String)

@EventType
data class CommandSetForDeclarativeNestedBasic(val name: String, val schema: String)

@EventType
data class CommandClearedForDeclarativeNestedBasic(val placeholder: Boolean = true)

data class SliceForNestedBasic(
    val name: String = "",
    val command: CommandItemForNestedBasic? = null
)

data class CommandItemForNestedBasic(
    val name: String = "",
    val schema: String = ""
)

class SliceProjectionForNestedBasic : IProjectionFor<SliceForNestedBasic> {
    override fun define(builder: IProjectionBuilderFor<SliceForNestedBasic>) {
        builder
            .from(SliceCreatedForNestedBasic::class)
            .nested(SliceForNestedBasic::command, CommandItemForNestedBasic::class) { nested ->
                nested
                    .from(CommandSetForDeclarativeNestedBasic::class)
                    .clearWith(CommandClearedForDeclarativeNestedBasic::class)
            }
    }
}

Java

Nested object projection

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

@EventType
record SliceCreatedForNestedBasic(String name) {}

@EventType
record CommandSetForDeclarativeNestedBasic(String name, String schema) {}

@EventType
record CommandClearedForDeclarativeNestedBasic() {}

record SliceForNestedBasic(String name, CommandItemForNestedBasic command) {}

record CommandItemForNestedBasic(String name, String schema) {}

class SliceProjectionForNestedBasic implements IProjectionFor<SliceForNestedBasic> {
    @Override
    public void define(IProjectionBuilderFor<SliceForNestedBasic> builder) {
        builder
            .from(SliceCreatedForNestedBasic.class)
            .nested("command", CommandItemForNestedBasic.class, nested -> {
                nested
                    .from(CommandSetForDeclarativeNestedBasic.class)
                    .clearWith(CommandClearedForDeclarativeNestedBasic.class);
            });
    }
}

Elixir

Elixir does not support this workflow yet.

TypeScript

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

@eventType()
class SliceCreatedForNestedBasic {
    constructor(readonly name: string) {}
}

@eventType()
class CommandSetForDeclarativeNestedBasic {
    constructor(readonly name: string, readonly schema: string) {}
}

@eventType()
class CommandClearedForDeclarativeNestedBasic {
}

class CommandItemForNestedBasic {
    name = '';
    schema = '';
}

class SliceForNestedBasic {
    name = '';
    command: CommandItemForNestedBasic | null = null;
}

@projection()
class SliceProjectionForNestedBasic implements IProjectionFor<SliceForNestedBasic> {
    define(builder: IProjectionBuilderFor<SliceForNestedBasic>): void {
        builder
            .from(SliceCreatedForNestedBasic)
            .nested(m => m.command, nested => nested
                .from(CommandSetForDeclarativeNestedBasic)
                .clearWith(CommandClearedForDeclarativeNestedBasic));
    }
}

Read model with a nested property

The nested property must be nullable on the read model:

C#

Read model with nested object

public record SliceWithNestedCommand(
    string Name,
    CommandItemForNestedCommand? Command);

public record CommandItemForNestedCommand(
    string Name,
    string Schema);

Kotlin

Read model with nested object

data class SliceWithNestedCommand(
    val name: String = "",
    val command: CommandItemForNestedCommand? = null
)

data class CommandItemForNestedCommand(
    val name: String = "",
    val schema: String = ""
)

Java

Read model with nested object

record SliceWithNestedCommand(String name, CommandItemForNestedCommand command) {}

record CommandItemForNestedCommand(String name, String schema) {}

Elixir

Elixir does not support this workflow yet.

TypeScript

class CommandItemForNestedCommand {
    name = '';
    schema = '';
}

class SliceWithNestedCommand {
    name = '';
    command: CommandItemForNestedCommand | null = null;
}

Event definitions

C#

Nested object events

using Cratis.Chronicle.Events;

[EventType]
public record SliceCreatedForNestedEvents(string Name);

[EventType]
public record CommandSetForNestedEvents(string Name, string Schema);

[EventType]
public record CommandClearedForNestedEvents;

Kotlin

Nested object events

import io.cratis.chronicle.events.EventType

@EventType
data class SliceCreatedForNestedEvents(val name: String)

@EventType
data class CommandSetForNestedEvents(val name: String, val schema: String)

@EventType
data class CommandClearedForNestedEvents(val placeholder: Boolean = true)

Java

Nested object events

import io.cratis.chronicle.events.EventType;

@EventType
record SliceCreatedForNestedEvents(String name) {}

@EventType
record CommandSetForNestedEvents(String name, String schema) {}

@EventType
record CommandClearedForNestedEvents() {}

Elixir

Elixir does not support this workflow yet.

TypeScript

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

@eventType()
class SliceCreatedForNestedEvents {
    constructor(readonly name: string) {}
}

@eventType()
class CommandSetForNestedEvents {
    constructor(readonly name: string, readonly schema: string) {}
}

@eventType()
class CommandClearedForNestedEvents {
}

How nested objects work

1. When CommandSetForSlice is appended the Command property is populated on the parent
2. Subsequent CommandSetForSlice events replace the nested object with new values
3. When CommandClearedForSlice is appended the Command property is set to null

Multiple from events

Call From<TEvent>() multiple times to update the nested object from several event types:

C#

Multiple nested events

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

[EventType]
public record SliceCreatedForNestedUpdates(string Name);

[EventType]
public record CommandSetForNestedUpdates(string Name, string Schema);

[EventType]
public record CommandRenamedForNestedUpdates(string NewName);

[EventType]
public record CommandSchemaUpdatedForNestedUpdates(string UpdatedSchema);

[EventType]
public record CommandClearedForNestedUpdates;

public record SliceForNestedUpdates(
    string Name,
    CommandItemForNestedUpdates? Command);

public record CommandItemForNestedUpdates(
    string Name,
    string Schema);

public class SliceProjectionForNestedUpdates : IProjectionFor<SliceForNestedUpdates>
{
    public void Define(IProjectionBuilderFor<SliceForNestedUpdates> builder) => builder
        .From<SliceCreatedForNestedUpdates>()
        .Nested(m => m.Command, nested => nested
            .From<CommandSetForNestedUpdates>()
            .From<CommandRenamedForNestedUpdates>(b => b
                .Set(m => m.Name).To(e => e.NewName))
            .From<CommandSchemaUpdatedForNestedUpdates>(b => b
                .Set(m => m.Schema).To(e => e.UpdatedSchema))
            .ClearWith<CommandClearedForNestedUpdates>());
}

Kotlin

Multiple nested events

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

@EventType
data class SliceCreatedForNestedUpdates(val name: String)

@EventType
data class CommandSetForNestedUpdates(val name: String, val schema: String)

@EventType
data class CommandRenamedForNestedUpdates(val newName: String)

@EventType
data class CommandSchemaUpdatedForNestedUpdates(val updatedSchema: String)

@EventType
data class CommandClearedForNestedUpdates(val placeholder: Boolean = true)

data class SliceForNestedUpdates(
    val name: String = "",
    val command: CommandItemForNestedUpdates? = null
)

data class CommandItemForNestedUpdates(
    val name: String = "",
    val schema: String = ""
)

class SliceProjectionForNestedUpdates : IProjectionFor<SliceForNestedUpdates> {
    override fun define(builder: IProjectionBuilderFor<SliceForNestedUpdates>) {
        builder
            .from(SliceCreatedForNestedUpdates::class)
            .nested(SliceForNestedUpdates::command, CommandItemForNestedUpdates::class) { nested ->
                nested
                    .from(CommandSetForNestedUpdates::class)
                    .from(CommandRenamedForNestedUpdates::class) {
                        it.set(CommandItemForNestedUpdates::name).to { e -> e.newName }
                    }
                    .from(CommandSchemaUpdatedForNestedUpdates::class) {
                        it.set(CommandItemForNestedUpdates::schema).to { e -> e.updatedSchema }
                    }
                    .clearWith(CommandClearedForNestedUpdates::class)
            }
    }
}

Java

Multiple nested events

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

@EventType
record SliceCreatedForNestedUpdates(String name) {}

@EventType
record CommandSetForNestedUpdates(String name, String schema) {}

@EventType
record CommandRenamedForNestedUpdates(String newName) {}

@EventType
record CommandSchemaUpdatedForNestedUpdates(String updatedSchema) {}

@EventType
record CommandClearedForNestedUpdates() {}

record SliceForNestedUpdates(String name, CommandItemForNestedUpdates command) {}

record CommandItemForNestedUpdates(String name, String schema) {}

class SliceProjectionForNestedUpdates implements IProjectionFor<SliceForNestedUpdates> {
    @Override
    public void define(IProjectionBuilderFor<SliceForNestedUpdates> builder) {
        builder
            .from(SliceCreatedForNestedUpdates.class)
            .nested("command", CommandItemForNestedUpdates.class, nested -> {
                nested
                    .from(CommandSetForNestedUpdates.class)
                    .from(CommandRenamedForNestedUpdates.class, fb -> {
                        fb.<String>set("name").to(e -> e.newName());
                    })
                    .from(CommandSchemaUpdatedForNestedUpdates.class, fb -> {
                        fb.<String>set("schema").to(e -> e.updatedSchema());
                    })
                    .clearWith(CommandClearedForNestedUpdates.class);
            });
    }
}

Elixir

Elixir does not support this workflow yet.

TypeScript

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

@eventType()
class SliceCreatedForNestedUpdates {
    constructor(readonly name: string) {}
}

@eventType()
class CommandSetForNestedUpdates {
    constructor(readonly name: string, readonly schema: string) {}
}

@eventType()
class CommandRenamedForNestedUpdates {
    constructor(readonly newName: string) {}
}

@eventType()
class CommandSchemaUpdatedForNestedUpdates {
    constructor(readonly updatedSchema: string) {}
}

@eventType()
class CommandClearedForNestedUpdates {
}

class CommandItemForNestedUpdates {
    name = '';
    schema = '';
}

class SliceForNestedUpdates {
    name = '';
    command: CommandItemForNestedUpdates | null = null;
}

@projection()
class SliceProjectionForNestedUpdates implements IProjectionFor<SliceForNestedUpdates> {
    define(builder: IProjectionBuilderFor<SliceForNestedUpdates>): void {
        builder
            .from(SliceCreatedForNestedUpdates)
            .nested<CommandItemForNestedUpdates>(m => m.command, nested => nested
                .from(CommandSetForNestedUpdates)
                .from(CommandRenamedForNestedUpdates, b => b
                    .set(m => m.name).to(e => e.newName))
                .from(CommandSchemaUpdatedForNestedUpdates, b => b
                    .set(m => m.schema).to(e => e.updatedSchema))
                .clearWith(CommandClearedForNestedUpdates));
    }
}

Each From<TEvent>() call updates only the properties it explicitly maps or auto-maps — it does not replace the entire nested object.

AutoMap on nested objects

AutoMap is enabled on the nested builder and inherits from the parent. Properties on the nested read model that share a name with properties on the event are mapped automatically:

C#

AutoMap in a nested scope

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

[EventType]
public record SliceCreatedForNestedAutoMap(string Name);

[EventType]
public record CommandSetForNestedAutoMap(string Name, string Schema);

[EventType]
public record CommandUpdatedForNestedAutoMap(string Schema);

[EventType]
public record CommandClearedForNestedAutoMap;

public record SliceForNestedAutoMap(
    string Name,
    CommandItemForNestedAutoMap? Command);

public record CommandItemForNestedAutoMap(
    string Name,
    string Schema);

public class SliceProjectionForNestedAutoMap : IProjectionFor<SliceForNestedAutoMap>
{
    public void Define(IProjectionBuilderFor<SliceForNestedAutoMap> builder) => builder
        .From<SliceCreatedForNestedAutoMap>()
        .Nested(m => m.Command, nested => nested
            .From<CommandSetForNestedAutoMap>()
            .From<CommandUpdatedForNestedAutoMap>()
            .ClearWith<CommandClearedForNestedAutoMap>());
}

Kotlin

AutoMap in a nested scope

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

@EventType
data class SliceCreatedForNestedAutoMap(val name: String)

@EventType
data class CommandSetForNestedAutoMap(val name: String, val schema: String)

@EventType
data class CommandUpdatedForNestedAutoMap(val schema: String)

@EventType
data class CommandClearedForNestedAutoMap(val placeholder: Boolean = true)

data class SliceForNestedAutoMap(
    val name: String = "",
    val command: CommandItemForNestedAutoMap? = null
)

data class CommandItemForNestedAutoMap(
    val name: String = "",
    val schema: String = ""
)

class SliceProjectionForNestedAutoMap : IProjectionFor<SliceForNestedAutoMap> {
    override fun define(builder: IProjectionBuilderFor<SliceForNestedAutoMap>) {
        builder
            .from(SliceCreatedForNestedAutoMap::class)
            .nested(SliceForNestedAutoMap::command, CommandItemForNestedAutoMap::class) { nested ->
                nested
                    .from(CommandSetForNestedAutoMap::class)
                    .from(CommandUpdatedForNestedAutoMap::class)
                    .clearWith(CommandClearedForNestedAutoMap::class)
            }
    }
}

Java

AutoMap in a nested scope

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

@EventType
record SliceCreatedForNestedAutoMap(String name) {}

@EventType
record CommandSetForNestedAutoMap(String name, String schema) {}

@EventType
record CommandUpdatedForNestedAutoMap(String schema) {}

@EventType
record CommandClearedForNestedAutoMap() {}

record SliceForNestedAutoMap(String name, CommandItemForNestedAutoMap command) {}

record CommandItemForNestedAutoMap(String name, String schema) {}

class SliceProjectionForNestedAutoMap implements IProjectionFor<SliceForNestedAutoMap> {
    @Override
    public void define(IProjectionBuilderFor<SliceForNestedAutoMap> builder) {
        builder
            .from(SliceCreatedForNestedAutoMap.class)
            .nested("command", CommandItemForNestedAutoMap.class, nested -> {
                nested
                    .from(CommandSetForNestedAutoMap.class)
                    .from(CommandUpdatedForNestedAutoMap.class)
                    .clearWith(CommandClearedForNestedAutoMap.class);
            });
    }
}

Elixir

Elixir does not support this workflow yet.

TypeScript

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

@eventType()
class SliceCreatedForNestedAutoMap {
    constructor(readonly name: string) {}
}

@eventType()
class CommandSetForNestedAutoMap {
    constructor(readonly name: string, readonly schema: string) {}
}

@eventType()
class CommandUpdatedForNestedAutoMap {
    constructor(readonly schema: string) {}
}

@eventType()
class CommandClearedForNestedAutoMap {
}

class CommandItemForNestedAutoMap {
    name = '';
    schema = '';
}

class SliceForNestedAutoMap {
    name = '';
    command: CommandItemForNestedAutoMap | null = null;
}

@projection()
class SliceProjectionForNestedAutoMap implements IProjectionFor<SliceForNestedAutoMap> {
    define(builder: IProjectionBuilderFor<SliceForNestedAutoMap>): void {
        builder
            .from(SliceCreatedForNestedAutoMap)
            .nested(m => m.command, nested => nested
                .from(CommandSetForNestedAutoMap)
                .from(CommandUpdatedForNestedAutoMap)
                .clearWith(CommandClearedForNestedAutoMap));
    }
}

Multiple nested objects

A single projection can have multiple independent nested properties:

C#

Multiple nested objects

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

[EventType]
public record SliceCreatedWithMultipleNested(string Name);

[EventType]
public record CommandSetWithMultipleNested(string Name, string Schema);

[EventType]
public record CommandClearedWithMultipleNested;

[EventType]
public record ValidationConfiguredWithMultipleNested(string RuleName);

[EventType]
public record ValidationRemovedWithMultipleNested;

public record SliceWithMultipleNested(
    string Name,
    CommandItemWithMultipleNested? Command,
    ValidationConfigWithMultipleNested? Validation);

public record CommandItemWithMultipleNested(
    string Name,
    string Schema);

public record ValidationConfigWithMultipleNested(
    string RuleName);

public class SliceProjectionWithMultipleNested : IProjectionFor<SliceWithMultipleNested>
{
    public void Define(IProjectionBuilderFor<SliceWithMultipleNested> builder) => builder
        .From<SliceCreatedWithMultipleNested>()
        .Nested(m => m.Command, nested => nested
            .From<CommandSetWithMultipleNested>()
            .ClearWith<CommandClearedWithMultipleNested>())
        .Nested(m => m.Validation, nested => nested
            .From<ValidationConfiguredWithMultipleNested>()
            .ClearWith<ValidationRemovedWithMultipleNested>());
}

Kotlin

Multiple nested objects

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

@EventType
data class SliceCreatedWithMultipleNested(val name: String)

@EventType
data class CommandSetWithMultipleNested(val name: String, val schema: String)

@EventType
data class CommandClearedWithMultipleNested(val placeholder: Boolean = true)

@EventType
data class ValidationConfiguredWithMultipleNested(val ruleName: String)

@EventType
data class ValidationRemovedWithMultipleNested(val placeholder: Boolean = true)

data class SliceWithMultipleNested(
    val name: String = "",
    val command: CommandItemWithMultipleNested? = null,
    val validation: ValidationConfigWithMultipleNested? = null
)

data class CommandItemWithMultipleNested(
    val name: String = "",
    val schema: String = ""
)

data class ValidationConfigWithMultipleNested(
    val ruleName: String = ""
)

class SliceProjectionWithMultipleNested : IProjectionFor<SliceWithMultipleNested> {
    override fun define(builder: IProjectionBuilderFor<SliceWithMultipleNested>) {
        builder
            .from(SliceCreatedWithMultipleNested::class)
            .nested(SliceWithMultipleNested::command, CommandItemWithMultipleNested::class) { nested ->
                nested
                    .from(CommandSetWithMultipleNested::class)
                    .clearWith(CommandClearedWithMultipleNested::class)
            }
            .nested(SliceWithMultipleNested::validation, ValidationConfigWithMultipleNested::class) { nested ->
                nested
                    .from(ValidationConfiguredWithMultipleNested::class)
                    .clearWith(ValidationRemovedWithMultipleNested::class)
            }
    }
}

Java

Multiple nested objects

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

@EventType
record SliceCreatedWithMultipleNested(String name) {}

@EventType
record CommandSetWithMultipleNested(String name, String schema) {}

@EventType
record CommandClearedWithMultipleNested() {}

@EventType
record ValidationConfiguredWithMultipleNested(String ruleName) {}

@EventType
record ValidationRemovedWithMultipleNested() {}

record SliceWithMultipleNested(
    String name,
    CommandItemWithMultipleNested command,
    ValidationConfigWithMultipleNested validation) {}

record CommandItemWithMultipleNested(String name, String schema) {}

record ValidationConfigWithMultipleNested(String ruleName) {}

class SliceProjectionWithMultipleNested implements IProjectionFor<SliceWithMultipleNested> {
    @Override
    public void define(IProjectionBuilderFor<SliceWithMultipleNested> builder) {
        builder
            .from(SliceCreatedWithMultipleNested.class)
            .nested("command", CommandItemWithMultipleNested.class, nested -> {
                nested
                    .from(CommandSetWithMultipleNested.class)
                    .clearWith(CommandClearedWithMultipleNested.class);
            })
            .nested("validation", ValidationConfigWithMultipleNested.class, nested -> {
                nested
                    .from(ValidationConfiguredWithMultipleNested.class)
                    .clearWith(ValidationRemovedWithMultipleNested.class);
            });
    }
}

Elixir

Elixir does not support this workflow yet.

TypeScript

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

@eventType()
class SliceCreatedWithMultipleNested {
    constructor(readonly name: string) {}
}

@eventType()
class CommandSetWithMultipleNested {
    constructor(readonly name: string, readonly schema: string) {}
}

@eventType()
class CommandClearedWithMultipleNested {
}

@eventType()
class ValidationConfiguredWithMultipleNested {
    constructor(readonly ruleName: string) {}
}

@eventType()
class ValidationRemovedWithMultipleNested {
}

class CommandItemWithMultipleNested {
    name = '';
    schema = '';
}

class ValidationConfigWithMultipleNested {
    ruleName = '';
}

class SliceWithMultipleNested {
    name = '';
    command: CommandItemWithMultipleNested | null = null;
    validation: ValidationConfigWithMultipleNested | null = null;
}

@projection()
class SliceProjectionWithMultipleNested implements IProjectionFor<SliceWithMultipleNested> {
    define(builder: IProjectionBuilderFor<SliceWithMultipleNested>): void {
        builder
            .from(SliceCreatedWithMultipleNested)
            .nested(m => m.command, nested => nested
                .from(CommandSetWithMultipleNested)
                .clearWith(CommandClearedWithMultipleNested))
            .nested(m => m.validation, nested => nested
                .from(ValidationConfiguredWithMultipleNested)
                .clearWith(ValidationRemovedWithMultipleNested));
    }
}

Nested within children

You can call Nested() from within a Children() builder to define a nested object on each child item:

C#

Nested object in children

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

[EventType]
public record ProjectCreatedWithNestedChildren(string Name);

[EventType]
public record TaskAddedWithNestedChild(Guid TaskId, string Title);

[EventType]
public record TaskAssignedWithNestedChild(Guid TaskId, string Name, string Email);

[EventType]
public record TaskUnassignedWithNestedChild(Guid TaskId);

public record ProjectWithDeclarativeNestedChildren(
    string Name,
    IEnumerable<TaskWithNestedAssignee> Tasks);

public record TaskWithNestedAssignee(
    Guid TaskId,
    string Title,
    AssigneeForNestedChild? Assignee);

public record AssigneeForNestedChild(
    string Name,
    string Email);

public class ProjectProjectionWithDeclarativeNestedChildren : IProjectionFor<ProjectWithDeclarativeNestedChildren>
{
    public void Define(IProjectionBuilderFor<ProjectWithDeclarativeNestedChildren> builder) => builder
        .From<ProjectCreatedWithNestedChildren>()
        .Children(m => m.Tasks, tasks => tasks
            .IdentifiedBy(m => m.TaskId)
            .From<TaskAddedWithNestedChild>(b => b
                .UsingKey(e => e.TaskId))
            .Nested(m => m.Assignee, assignee => assignee
                .From<TaskAssignedWithNestedChild>(b => b
                    .UsingKey(e => e.TaskId))
                .ClearWith<TaskUnassignedWithNestedChild>()));
}

Kotlin

Kotlin does not support this workflow yet.
`IChildrenBuilderFor`/`IChildFromBuilderFor` have no `nested()` method — `nested()` exists only on
the top-level `IProjectionBuilderFor<TReadModel>`, so a nested object cannot be declared on a child
item inside a `children()` scope.

Java

Java does not support this workflow yet.
`IChildrenBuilderFor`/`IChildFromBuilderFor` have no `nested()` method — `nested()` exists only on
the top-level `IProjectionBuilderFor<TReadModel>`, so a nested object cannot be declared on a child
item inside a `children()` scope.

Elixir

Elixir does not support this workflow yet.

TypeScript

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

@eventType()
class ProjectCreatedWithNestedChildren {
    constructor(readonly name: string) {}
}

@eventType()
class TaskAddedWithNestedChild {
    constructor(readonly taskId: string, readonly title: string) {}
}

@eventType()
class TaskAssignedWithNestedChild {
    constructor(readonly taskId: string, readonly name: string, readonly email: string) {}
}

@eventType()
class TaskUnassignedWithNestedChild {
    constructor(readonly taskId: string) {}
}

class AssigneeForNestedChild {
    name = '';
    email = '';
}

class TaskWithNestedAssignee {
    taskId = '';
    title = '';
    assignee: AssigneeForNestedChild | null = null;
}

class ProjectWithDeclarativeNestedChildren {
    name = '';
    tasks: TaskWithNestedAssignee[] = [];
}

@projection()
class ProjectProjectionWithDeclarativeNestedChildren implements IProjectionFor<ProjectWithDeclarativeNestedChildren> {
    define(builder: IProjectionBuilderFor<ProjectWithDeclarativeNestedChildren>): void {
        builder
            .from(ProjectCreatedWithNestedChildren)
            .children<TaskWithNestedAssignee>(m => m.tasks, tasks => tasks
                .identifiedBy(m => m.taskId)
                .from(TaskAddedWithNestedChild, b => b
                    .usingKey(e => e.taskId))
                .nested(m => m.assignee, assignee => assignee
                    .from(TaskAssignedWithNestedChild, b => b
                        .usingKey(e => e.taskId))
                    .clearWith(TaskUnassignedWithNestedChild)));
    }
}

Examples

Employee with optional active contract

C#

Employee contract projection

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

[EventType]
public record EmployeeHiredWithNestedContract(string Name, string Department);

[EventType]
public record ContractStartedWithNestedContract(Guid ContractId, DateOnly StartDate, DateOnly EndDate, string Type);

[EventType]
public record ContractExtendedWithNestedContract(DateOnly NewEndDate);

[EventType]
public record ContractEndedWithNestedContract;

public record EmployeeWithNestedContract(
    string Name,
    string Department,
    ContractForNestedEmployee? ActiveContract);

public record ContractForNestedEmployee(
    Guid ContractId,
    DateOnly StartDate,
    DateOnly EndDate,
    string Type);

public class EmployeeProjectionWithNestedContract : IProjectionFor<EmployeeWithNestedContract>
{
    public void Define(IProjectionBuilderFor<EmployeeWithNestedContract> builder) => builder
        .From<EmployeeHiredWithNestedContract>()
        .Nested(m => m.ActiveContract, contract => contract
            .From<ContractStartedWithNestedContract>()
            .From<ContractExtendedWithNestedContract>(b => b
                .Set(m => m.EndDate).To(e => e.NewEndDate))
            .ClearWith<ContractEndedWithNestedContract>());
}

Kotlin

Employee contract projection

import io.cratis.chronicle.events.EventType
import io.cratis.chronicle.projections.IProjectionBuilderFor
import io.cratis.chronicle.projections.IProjectionFor
import java.time.LocalDate

@EventType
data class EmployeeHiredWithNestedContract(val name: String, val department: String)

@EventType
data class ContractStartedWithNestedContract(
    val contractId: String,
    val startDate: LocalDate,
    val endDate: LocalDate,
    val type: String
)

@EventType
data class ContractExtendedWithNestedContract(val newEndDate: LocalDate)

@EventType
data class ContractEndedWithNestedContract(val placeholder: Boolean = true)

data class EmployeeWithNestedContract(
    val name: String = "",
    val department: String = "",
    val activeContract: ContractForNestedEmployee? = null
)

data class ContractForNestedEmployee(
    val contractId: String = "",
    val startDate: LocalDate = LocalDate.MIN,
    val endDate: LocalDate = LocalDate.MIN,
    val type: String = ""
)

class EmployeeProjectionWithNestedContract : IProjectionFor<EmployeeWithNestedContract> {
    override fun define(builder: IProjectionBuilderFor<EmployeeWithNestedContract>) {
        builder
            .from(EmployeeHiredWithNestedContract::class)
            .nested(EmployeeWithNestedContract::activeContract, ContractForNestedEmployee::class) { contract ->
                contract
                    .from(ContractStartedWithNestedContract::class)
                    .from(ContractExtendedWithNestedContract::class) {
                        it.set(ContractForNestedEmployee::endDate).to { e -> e.newEndDate }
                    }
                    .clearWith(ContractEndedWithNestedContract::class)
            }
    }
}

Java

Employee contract projection

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

import java.time.LocalDate;

record EmployeeWithNestedContract(String name, String department, ContractForNestedEmployee activeContract) {}

record ContractForNestedEmployee(String contractId, LocalDate startDate, LocalDate endDate, String type) {}

class EmployeeProjectionWithNestedContract implements IProjectionFor<EmployeeWithNestedContract> {
    @Override
    public void define(IProjectionBuilderFor<EmployeeWithNestedContract> builder) {
        builder
            .from(EmployeeHiredForNestedContractEvents.class)
            .nested("activeContract", ContractForNestedEmployee.class, contract -> {
                contract
                    .from(ContractStartedForNestedContractEvents.class)
                    .from(ContractExtendedForNestedContractEvents.class, fb -> {
                        fb.<LocalDate>set("endDate").to(e -> e.newEndDate());
                    })
                    .clearWith(ContractEndedForNestedContractEvents.class);
            });
    }
}

Elixir

Elixir does not support this workflow yet.

TypeScript

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

@eventType()
class EmployeeHiredWithNestedContract {
    constructor(readonly name: string, readonly department: string) {}
}

@eventType()
class ContractStartedWithNestedContract {
    constructor(
        readonly contractId: string,
        readonly startDate: string,
        readonly endDate: string,
        readonly type: string
    ) {}
}

@eventType()
class ContractExtendedWithNestedContract {
    constructor(readonly newEndDate: string) {}
}

@eventType()
class ContractEndedWithNestedContract {
}

class ContractForNestedEmployee {
    contractId = '';
    startDate = '';
    endDate = '';
    type = '';
}

class EmployeeWithNestedContract {
    name = '';
    department = '';
    activeContract: ContractForNestedEmployee | null = null;
}

@projection()
class EmployeeProjectionWithNestedContract implements IProjectionFor<EmployeeWithNestedContract> {
    define(builder: IProjectionBuilderFor<EmployeeWithNestedContract>): void {
        builder
            .from(EmployeeHiredWithNestedContract)
            .nested<ContractForNestedEmployee>(m => m.activeContract, contract => contract
                .from(ContractStartedWithNestedContract)
                .from(ContractExtendedWithNestedContract, b => b
                    .set(m => m.endDate).to(e => e.newEndDate))
                .clearWith(ContractEndedWithNestedContract));
    }
}

Events:

C#

Employee contract events

using Cratis.Chronicle.Events;

[EventType]
public record EmployeeHiredForNestedContractEvents(string Name, string Department);

[EventType]
public record ContractStartedForNestedContractEvents(Guid ContractId, DateOnly StartDate, DateOnly EndDate, string Type);

[EventType]
public record ContractExtendedForNestedContractEvents(DateOnly NewEndDate);

[EventType]
public record ContractEndedForNestedContractEvents;

Kotlin

Employee contract events

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

@EventType
data class EmployeeHiredForNestedContractEvents(val name: String, val department: String)

@EventType
data class ContractStartedForNestedContractEvents(
    val contractId: String,
    val startDate: LocalDate,
    val endDate: LocalDate,
    val type: String
)

@EventType
data class ContractExtendedForNestedContractEvents(val newEndDate: LocalDate)

@EventType
data class ContractEndedForNestedContractEvents(val placeholder: Boolean = true)

Java

Employee contract events

import io.cratis.chronicle.events.EventType;

import java.time.LocalDate;

@EventType
record EmployeeHiredForNestedContractEvents(String name, String department) {}

@EventType
record ContractStartedForNestedContractEvents(
    String contractId,
    LocalDate startDate,
    LocalDate endDate,
    String type
) {}

@EventType
record ContractExtendedForNestedContractEvents(LocalDate newEndDate) {}

@EventType
record ContractEndedForNestedContractEvents() {}

Elixir

Elixir does not support this workflow yet.

TypeScript

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

@eventType()
class EmployeeHiredForNestedContractEvents {
    constructor(readonly name: string, readonly department: string) {}
}

@eventType()
class ContractStartedForNestedContractEvents {
    constructor(
        readonly contractId: string,
        readonly startDate: string,
        readonly endDate: string,
        readonly type: string
    ) {}
}

@eventType()
class ContractExtendedForNestedContractEvents {
    constructor(readonly newEndDate: string) {}
}

@eventType()
class ContractEndedForNestedContractEvents {
}

Product with optional promotion

C#

Product promotion projection

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

[EventType]
public record ProductListedWithNestedPromotion(string Name, decimal BasePrice);

[EventType]
public record PromotionAppliedWithNestedPromotion(string Label, int DiscountPercent, DateTimeOffset ValidUntil);

[EventType]
public record PromotionRemovedWithNestedPromotion;

public record ProductWithNestedPromotion(
    string Name,
    decimal BasePrice,
    PromotionForNestedProduct? Promotion);

public record PromotionForNestedProduct(
    string Label,
    int DiscountPercent,
    DateTimeOffset ValidUntil);

public class ProductProjectionWithNestedPromotion : IProjectionFor<ProductWithNestedPromotion>
{
    public void Define(IProjectionBuilderFor<ProductWithNestedPromotion> builder) => builder
        .From<ProductListedWithNestedPromotion>()
        .Nested(m => m.Promotion, promotion => promotion
            .From<PromotionAppliedWithNestedPromotion>()
            .ClearWith<PromotionRemovedWithNestedPromotion>());
}

Kotlin

Product promotion projection

import io.cratis.chronicle.events.EventType
import io.cratis.chronicle.projections.IProjectionBuilderFor
import io.cratis.chronicle.projections.IProjectionFor
import java.time.Instant

@EventType
data class ProductListedWithNestedPromotion(val name: String, val basePrice: Double)

@EventType
data class PromotionAppliedWithNestedPromotion(
    val label: String,
    val discountPercent: Int,
    val validUntil: Instant
)

@EventType
data class PromotionRemovedWithNestedPromotion(val placeholder: Boolean = true)

data class ProductWithNestedPromotion(
    val name: String = "",
    val basePrice: Double = 0.0,
    val promotion: PromotionForNestedProduct? = null
)

data class PromotionForNestedProduct(
    val label: String = "",
    val discountPercent: Int = 0,
    val validUntil: Instant = Instant.EPOCH
)

class ProductProjectionWithNestedPromotion : IProjectionFor<ProductWithNestedPromotion> {
    override fun define(builder: IProjectionBuilderFor<ProductWithNestedPromotion>) {
        builder
            .from(ProductListedWithNestedPromotion::class)
            .nested(ProductWithNestedPromotion::promotion, PromotionForNestedProduct::class) { promotion ->
                promotion
                    .from(PromotionAppliedWithNestedPromotion::class)
                    .clearWith(PromotionRemovedWithNestedPromotion::class)
            }
    }
}

Java

Product promotion projection

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

import java.time.Instant;

@EventType
record ProductListedWithNestedPromotion(String name, double basePrice) {}

@EventType
record PromotionAppliedWithNestedPromotion(String label, int discountPercent, Instant validUntil) {}

@EventType
record PromotionRemovedWithNestedPromotion() {}

record ProductWithNestedPromotion(String name, double basePrice, PromotionForNestedProduct promotion) {}

record PromotionForNestedProduct(String label, int discountPercent, Instant validUntil) {}

class ProductProjectionWithNestedPromotion implements IProjectionFor<ProductWithNestedPromotion> {
    @Override
    public void define(IProjectionBuilderFor<ProductWithNestedPromotion> builder) {
        builder
            .from(ProductListedWithNestedPromotion.class)
            .nested("promotion", PromotionForNestedProduct.class, promotion -> {
                promotion
                    .from(PromotionAppliedWithNestedPromotion.class)
                    .clearWith(PromotionRemovedWithNestedPromotion.class);
            });
    }
}

Elixir

Elixir does not support this workflow yet.

TypeScript

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

@eventType()
class ProductListedWithNestedPromotion {
    constructor(readonly name: string, readonly basePrice: number) {}
}

@eventType()
class PromotionAppliedWithNestedPromotion {
    constructor(readonly label: string, readonly discountPercent: number, readonly validUntil: Date) {}
}

@eventType()
class PromotionRemovedWithNestedPromotion {
}

class PromotionForNestedProduct {
    label = '';
    discountPercent = 0;
    validUntil = new Date();
}

class ProductWithNestedPromotion {
    name = '';
    basePrice = 0;
    promotion: PromotionForNestedProduct | null = null;
}

@projection()
class ProductProjectionWithNestedPromotion implements IProjectionFor<ProductWithNestedPromotion> {
    define(builder: IProjectionBuilderFor<ProductWithNestedPromotion>): void {
        builder
            .from(ProductListedWithNestedPromotion)
            .nested(m => m.promotion, promotion => promotion
                .from(PromotionAppliedWithNestedPromotion)
                .clearWith(PromotionRemovedWithNestedPromotion));
    }
}

See Also

• Children — collections of items managed independently within a parent
• Simple projection — getting started with projections
• AutoMap — automatic property mapping