Camel Casing

Chronicle can apply a camel case naming policy when building projection definitions and persisting read models. This keeps property names consistent with common JSON naming conventions.

Overview

By default, Chronicle uses property names as they appear in C# (PascalCase). Enabling camel case will:

• Govern how projection definitions are built
• Determine the property names used when projections update read models
• Keep naming consistent across projection and read model data

Using a Direct Client

For direct ChronicleClient usage outside of a hosted application, pass a CamelCaseNamingPolicy instance via the named namingPolicy constructor argument:

C#

using Cratis.Chronicle;
using Cratis.Serialization;

public static class CamelCasingDirectClient
{
    public static ChronicleClient Create() =>
        new(options: new ChronicleOptions(), namingPolicy: new CamelCaseNamingPolicy());
}

Kotlin

Kotlin does not support this workflow yet.

Java

Java does not support this workflow yet.

Elixir

Elixir does not support this workflow yet.

TypeScript

TypeScript does not support this workflow yet.

Using ASP.NET Core

When building ASP.NET Core applications, use the dependency injection extensions to configure Chronicle with camel case naming policy.

Basic Configuration

In your Program.cs file, configure Chronicle with camel case naming policy using the IChronicleBuilder callback:

C#

using Microsoft.AspNetCore.Builder;

public static class CamelCasingAspNetCoreBasicRegistration
{
    public static void Configure(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        builder.AddCratisChronicle(
            configure: chronicleBuilder => chronicleBuilder.WithCamelCaseNamingPolicy());

        var app = builder.Build();
    }
}

Kotlin

Kotlin does not support this workflow yet.

Java

Java does not support this workflow yet.

Elixir

Elixir does not support this workflow yet.

TypeScript

TypeScript does not support this workflow yet.

Dependency Injection Configuration

You can combine camel case naming policy with other Chronicle configuration options:

C#

using Microsoft.AspNetCore.Builder;

public static class CamelCasingAspNetCoreWithOptionsRegistration
{
    public static void Configure(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        builder.AddCratisChronicle(
            configureOptions: options => options.EventStore = "MyEventStore",
            configure: chronicleBuilder => chronicleBuilder.WithCamelCaseNamingPolicy());

        var app = builder.Build();
    }
}

Kotlin

Kotlin does not support this workflow yet.

Java

Java does not support this workflow yet.

Elixir

Elixir does not support this workflow yet.

TypeScript

TypeScript does not support this workflow yet.

Using .NET Host (Worker Services)

For worker services or other non-web hosts using IHostApplicationBuilder:

C#

using Microsoft.Extensions.Hosting;

public static class CamelCasingWorkerHostRegistration
{
    public static void Configure(string[] args)
    {
        var builder = Host.CreateApplicationBuilder(args);

        builder.AddCratisChronicle(
            configure: chronicleBuilder => chronicleBuilder.WithCamelCaseNamingPolicy());

        var host = builder.Build();
    }
}

Kotlin

Kotlin does not support this workflow yet.

Java

Java does not support this workflow yet.

Elixir

Elixir does not support this workflow yet.

TypeScript

TypeScript does not support this workflow yet.

Impact on Projections

The naming policy configuration affects how Chronicle handles projections:

Projection Definition Building

When you configure camel case naming policy, Chronicle uses this policy when building projection definitions. This means property mappings within projections will use camel case property names.

Read Models

The naming policy affects the read model container name, which affects the name of the collection, table, or file that data is persisted as.

When projections project to read models, the property names used will follow the configured naming policy. For example:

Event Definition

C#

using Cratis.Chronicle.Events;

[EventType]
public record CamelCasingUserRegistered(
    string FirstName,
    string LastName,
    string EmailAddress,
    DateTime RegistrationDate);

Kotlin

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

@EventType
data class CamelCasingUserRegistered(
    val firstName: String = "",
    val lastName: String = "",
    val emailAddress: String = "",
    val registrationDate: Instant = Instant.EPOCH
)

Java

import io.cratis.chronicle.events.EventType;

import java.time.Instant;

@EventType
record CamelCasingUserRegistered(
    String firstName,
    String lastName,
    String emailAddress,
    Instant registrationDate) {
}

Elixir

defmodule MyApp.Events.CamelCasingUserRegistered do
  use Chronicle.Events.EventType, id: "camel-casing-user-registered"

  defstruct [:first_name, :last_name, :email_address, :registration_date]
end

TypeScript

TypeScript does not support this workflow yet.

Read Model Definition

C#

public class CamelCasingUserReadModel
{
    public string FirstName { get; set; } = string.Empty;
    public string LastName { get; set; } = string.Empty;
    public string EmailAddress { get; set; } = string.Empty;
    public DateTime RegistrationDate { get; set; }
}

Kotlin

import io.cratis.chronicle.readModels.ReadModel
import java.time.Instant

@ReadModel
data class CamelCasingUserReadModel(
    val firstName: String = "",
    val lastName: String = "",
    val emailAddress: String = "",
    val registrationDate: Instant = Instant.EPOCH
)

Java

import io.cratis.chronicle.readModels.ReadModel;

import java.time.Instant;

@ReadModel
class CamelCasingUserReadModel {
    public String firstName = "";
    public String lastName = "";
    public String emailAddress = "";
    public Instant registrationDate = Instant.EPOCH;
}

Elixir

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

  defstruct first_name: nil, last_name: nil, email_address: nil, registration_date: nil
end

TypeScript

TypeScript does not support this workflow yet.

Projection with Camel Case Naming Policy

With camel case naming policy configured, Chronicle will use camel case property names when building the projection:

C#

using Cratis.Chronicle.Projections;

public class CamelCasingUserProjection : IProjectionFor<CamelCasingUserReadModel>
{
    public void Define(IProjectionBuilderFor<CamelCasingUserReadModel> builder) => builder
        .From<CamelCasingUserRegistered>(_ => _
            .Set(m => m.FirstName).To(e => e.FirstName)
            .Set(m => m.LastName).To(e => e.LastName)
            .Set(m => m.EmailAddress).To(e => e.EmailAddress)
            .Set(m => m.RegistrationDate).To(e => e.RegistrationDate));
}

Kotlin

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

// Kotlin property names are already camelCase, so the projected read model properties below —
// firstName, lastName, emailAddress, registrationDate — need no naming policy configuration to
// come out as camelCase; that is simply how Kotlin properties are named.
class CamelCasingUserProjection : IProjectionFor<CamelCasingUserReadModel> {
    override fun define(builder: IProjectionBuilderFor<CamelCasingUserReadModel>) {
        builder.from(CamelCasingUserRegistered::class) {
            it.set(CamelCasingUserReadModel::firstName).to { e -> e.firstName }
            it.set(CamelCasingUserReadModel::lastName).to { e -> e.lastName }
            it.set(CamelCasingUserReadModel::emailAddress).to { e -> e.emailAddress }
            it.set(CamelCasingUserReadModel::registrationDate).to { e -> e.registrationDate }
        }
    }
}

Java

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

// Java field names are already camelCase, and AutoMap matches read model properties to event
// properties of the same name — firstName, lastName, emailAddress, registrationDate — so no
// naming policy configuration is needed to have them come out as camelCase.
class CamelCasingUserProjection implements IProjectionFor<CamelCasingUserReadModel> {
    @Override
    public void define(IProjectionBuilderFor<CamelCasingUserReadModel> builder) {
        ProjectionBuilderJavaBridge.from(builder, CamelCasingUserRegistered.class);
    }
}

Elixir

defmodule MyApp.Projections.CamelCasingUserProjection do
  use Chronicle.Projections.Projection, model: MyApp.ReadModels.CamelCasingUser

  from MyApp.Events.CamelCasingUserRegistered,
    set: [
      first_name: :first_name,
      last_name: :last_name,
      email_address: :email_address,
      registration_date: :registration_date
    ]
end

TypeScript

TypeScript does not support this workflow yet.

The resulting read model data will have camel case property names: firstName, lastName, emailAddress, registrationDate.

Important Notes

• The naming policy affects how Chronicle builds projection definitions internally.
• Property names in read models will follow the configured naming policy when data is persisted.
• This configuration is specific to Chronicle operations and does not affect general ASP.NET Core JSON serialization.
• All projections in your application will use the same naming policy once configured.

Troubleshooting

Projection Property Names Not Converting

If projection property names are not being converted to camel case:

1. Verify that WithCamelCaseNamingPolicy() is called on the IChronicleBuilder during Chronicle configuration.
2. Ensure the configuration is applied before Chronicle services are initialized.
3. Check that all projections are using the same Chronicle client instance.

Inconsistent Property Naming

If you see inconsistent property naming in your read models:

1. Verify that Chronicle is configured with the camel case naming policy via IChronicleBuilder.WithCamelCaseNamingPolicy().
2. Check if any custom property mappings are overriding the global naming policy.
3. Ensure all projection definitions are rebuilt after changing the naming policy.