Fixing docs

Author: einari

Documentation/clients/dotnet/events/projections.md

@@ -40,4 +40,25 @@ automatically discovered and registered with Chronicle.
 
 A more concrete example of a projection with one-to-one relationship:
 
-{{snippet:Quickstart-BorrowedBooksProjection}}
+```csharp
+using Cratis.Chronicle.Projections;
+
+namespace Quickstart.Common;
+
+public class BorrowedBooksProjection : IProjectionFor<BorrowedBook>
+{
+    public void Define(IProjectionBuilderFor<BorrowedBook> builder) => builder
+        .From<BookBorrowed>(from => from
+            .Set(m => m.UserId).To(e => e.UserId)
+            .Set(m => m.Borrowed).ToEventContextProperty(c => c.Occurred))
+        .Join<BookAddedToInventory>(bookBuilder => bookBuilder
+            .On(m => m.Id)
+            .Set(m => m.Title).To(e => e.Title))
+        .Join<UserOnboarded>(userBuilder => userBuilder
+            .On(m => m.UserId)
+            .Set(m => m.User).To(e => e.Name))
+        .RemovedWith<BookReturned>();
+}
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/BorrowedBooksProjection.cs#L5-L22)

Documentation/clients/dotnet/events/reducers.md

@@ -42,4 +42,17 @@ If there is no instance, this value will be null.
 
 A concrete example of a reducer:
 
-{{snippet:Quickstart-BooksReducer}}
+```csharp
+using Cratis.Chronicle.Events;
+using Cratis.Chronicle.Reducers;
+
+namespace Quickstart.Common;
+
+public class BooksReducer : IReducerFor<Book>
+{
+    public Task<Book> Added(BookAddedToInventory @event, Book? initialState, EventContext context) =>
+         Task.FromResult(new Book(Guid.Parse(@context.EventSourceId), @event.Title, @event.Author, @event.ISBN));
+}
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/BooksReducer.cs#L5-L14)

Documentation/clients/dotnet/toc.yml

@@ -6,8 +6,6 @@
   href: events/events.md
 - name: Concurrency
   href: events/concurrency.md
-- name: Aggregate Root
-  href: aggregates/aggregate-root.md
 - name: Reactors
   href: events/reactors.md
 - name: OnceOnly

Documentation/clients/toc.yml

@@ -2,5 +2,3 @@
   href: dotnet/toc.yml
 - name: ASP.NET Core Client
   href: aspnetcore/toc.yml
-- name: Application Model
-  href: application-model/toc.yml

Documentation/concepts/toc.yml

@@ -14,8 +14,6 @@
   href: observers.md
 - name: Projection
   href: projection.md
-- name: Categorizing Reactors
-  href: categorizing-reactors.md
 - name: Constraints
   href: constraints.md
 - name: Event Metadata Tags

Documentation/get-started/aspnetcore.md

@@ -37,13 +37,23 @@ Chronicle supports this paradigm out of the box, and there are convenience metho
 
 In your `Program.cs` simply change your setup to the following:
 
-{{snippet:Quickstart-AspNetCore-WebApplicationBuilder}}
+```csharp
+var builder = WebApplication.CreateBuilder(args)
+    .AddCratisChronicle(options => options.EventStore = "Quickstart");
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/AspNetCore/Program.cs#L19-L20)
 
 The code adds Chronicle to your application and sets the name of the event store to use.
 In contrast to what you need to do when running bare-bone as shown in the [console](./console.md) sample,
 all discovery and registration of artifacts will happen automatically.
 
-{{snippet:Quickstart-AspNetCore-WebApplication}}
+```csharp
+var app = builder.Build();
+app.UseCratisChronicle();
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/AspNetCore/Program.cs#L30-L31)
 
 [!INCLUDE [common](./common.md)]
 
@@ -52,7 +62,14 @@ all discovery and registration of artifacts will happen automatically.
 Appending events is typically something you would be doing directly, or indirectly through an API exposed as a minimal
 API or a Controller.
 
-{{snippet:Quickstart-AspNetCore-BookBorrowed}}
+```csharp
+        app.MapPost("/api/books/{bookId}/borrow/{userId}", async (
+            [FromServices] IEventLog eventLog,
+            [FromRoute] Guid bookId,
+            [FromRoute] Guid userId) => await eventLog.Append(bookId, new BookBorrowed(userId)));
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common.AspNetCore/Api.cs#L19-L22)
 
 The code exposes an API endpoint that takes parameters for what book to borrow and what user is borrowing it.
 It then appends a `BookBorrowed` event. The `bookId` is used as the [event source](../concepts/event-source.md), while
@@ -65,7 +82,15 @@ such as **Reactors**, **Reducers** and **Projections**.
 In order for this to work, the artifacts needs to be registered as services. In your `Program.cs` file you would add
 service registrations for the artifacts you have:
 
-{{snippet:Quickstart-AspNetCore-ArtifactsServices}}
+```csharp
+        builder.Services.AddTransient<UsersReactor>();
+        builder.Services.AddTransient<BooksReducer>();
+        builder.Services.AddTransient<BorrowedBooksProjection>();
+        builder.Services.AddTransient<OverdueBooksProjection>();
+        builder.Services.AddTransient<ReservedBooksProjection>();
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common.AspNetCore/CommonServices.cs#L14-L18)
 
 This can become very tedious to do as your solution grows, Cratis Fundamentals offers a way couple of extension methods
 that will automatically hook this up:
@@ -90,10 +115,23 @@ what you need; access to the specific database or specific collections.
 
 The following code shows how to set this up for your `WebApplicationBuilder` to enable that scenario.
 
-{{snippet:Quickstart-AspNetCore-MongoSetup}}
+```csharp
+        builder.Services.AddSingleton<IMongoClient>(new MongoClient("mongodb://localhost:27017"));
+        builder.Services.AddSingleton(provider => provider.GetRequiredService<IMongoClient>().GetDatabase("Quickstart"));
+        builder.Services.AddTransient(provider => provider.GetRequiredService<IMongoDatabase>().GetCollection<Book>("book"));
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common.AspNetCore/MongoDBServices.cs#L15-L17)
 
 > Note: The code adds service registrations for typed collections based on types found in the [sample code](https://github.com/Cratis/Samples/tree/main/Chronicle/Quickstart/Common).
 
 With this you can now quite easily create a type that encapsulates getting the data that takes a specific collection as a dependency:
 
-{{snippet:Quickstart-Books}}
+```csharp
+public class Books(IMongoCollection<Book> collection)
+{
+    public IEnumerable<Book> GetAll() => collection.Find(Builders<Book>.Filter.Empty).ToList();
+}
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/Books.cs#L9-L12)

Documentation/get-started/common.md

@@ -7,7 +7,18 @@ To define an event type, simply add the `[EventType]` attribute to the new type.
 
 Below is a set of events we will use for our library sample.
 
-{{snippet:Quickstart-Events}}
+```csharp
+[EventType]
+public record UserOnboarded(string Name, string Email);
+
+[EventType]
+public record BookAddedToInventory(string Title, string Author, string ISBN);
+
+[EventType]
+public record BookBorrowed(Guid UserId);
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/Events.cs#L9-L16)
 
 ## Appending events
 
@@ -27,11 +38,21 @@ In this example, we will use the method for appending a single event.
 
 The following code appends a couple of `UserOnboarded` events to indicate that users have been onboarded to the system.
 
-{{snippet:Quickstart-DemoData-Users}}
+```csharp
+        await eventLog.Append(Guid.NewGuid(), new UserOnboarded("Jane Doe", "jane@interwebs.net"));
+        await eventLog.Append(Guid.NewGuid(), new UserOnboarded("John Doe", "john@interwebs.net"));
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/DemoData.cs#L13-L14)
 
 Next, we want to append a couple of events to represent books being added to our inventory:
 
-{{snippet:Quickstart-DemoData-Books}}
+```csharp
+        await eventLog.Append(Guid.NewGuid(), new BookAddedToInventory("Metaprogramming in C#: Automate your .NET development and simplify overcomplicated code", "Einar Ingebrigtsen", "978-1837635429"));
+        await eventLog.Append(Guid.NewGuid(), new BookAddedToInventory("Understanding Eventsourcing: Planning and Implementing scalable Systems with Eventmodeling and Eventsourcing", "Martin Dilger", "979-8300933043"));
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/DemoData.cs#L18-L19)
 
 Notice that the first parameter for the `Append` method is the [event source identifier](../concepts/event-source.md).
 This identifier uniquely represents the object we're working on, similar to a **primary key** in a database.
@@ -63,11 +84,33 @@ It is ideal for *if-this-then-that* scenarios but can also be used for data crea
 
 Let's start by defining a read model that will be used in the reducer.
 
-{{snippet:Quickstart-User}}
+```csharp
+public record User(Guid Id, string Name, string Email)
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/User.cs#L7-L7)
 
 The following code reacts to the `UserOnboarded` event and then creates a new `User` and inserts into a MongoDB database.
 
-{{snippet:Quickstart-UsersReactor}}
+```csharp
+using Cratis.Chronicle.Events;
+using Cratis.Chronicle.Reactors;
+using MongoDB.Driver;
+
+namespace Quickstart;
+
+public class UsersReactor : IReactor
+{
+    public async Task Onboarded(UserOnboarded @event, EventContext context)
+    {
+        var user = new User(Guid.Parse(context.EventSourceId), @event.Name, @event.Email);
+        var collection = Globals.Database.GetCollection<User>("users");
+        await collection.InsertOneAsync(user);
+    }
+}
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Console/UsersReactor.cs#L5-L19)
 
 > Note: The code leverages a `Globals` object that is found as part of the full sample and is configured with the
 > MongoDB database to use.
@@ -95,12 +138,29 @@ It functions similarly to a **Reactor** but abstracts away the database manageme
 
 Let's begin by defining a read model that will be used in the reducer.
 
-{{snippet:Quickstart-Book}}
+```csharp
+public record Book(Guid Id, string Title, string Author, string ISBN)
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/Book.cs#L7-L7)
 
 For the read model we will need code that produces the correct state.
 The following code reacts to `BookAddedToInventory` and produces the new state that should be persisted.
 
-{{snippet:Quickstart-BooksReducer}}
+```csharp
+using Cratis.Chronicle.Events;
+using Cratis.Chronicle.Reducers;
+
+namespace Quickstart.Common;
+
+public class BooksReducer : IReducerFor<Book>
+{
+    public Task<Book> Added(BookAddedToInventory @event, Book? initialState, EventContext context) =>
+         Task.FromResult(new Book(Guid.Parse(@context.EventSourceId), @event.Title, @event.Author, @event.ISBN));
+}
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/BooksReducer.cs#L5-L14)
 
 The method `Added` is not defined by the `IReducerFor<>` interface. The `IReducerFor<>` interface serves as a marker interface for discovery purposes.
 It requires a generic argument specifying the type of the read model. Chronicle uses this type to gather information about properties and types for the underlying database.
@@ -131,12 +191,37 @@ and one-to-one. When your goal is to produce state, projections will often be su
 
 Let's start by defining a read model that will be used in the projection.
 
-{{snippet:Quickstart-BorrowedBook}}
+```csharp
+public record BorrowedBook(Guid Id, Guid UserId, string Title, string User, DateTimeOffset Borrowed, DateTimeOffset Returned)
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/BorrowedBook.cs#L7-L7)
 
 The projection declares operations to do in a fluent manner, effectively mapping out the events it is interested in and
 telling the projection engine what to do with them.
 
-{{snippet:Quickstart-BorrowedBooksProjection}}
+```csharp
+using Cratis.Chronicle.Projections;
+
+namespace Quickstart.Common;
+
+public class BorrowedBooksProjection : IProjectionFor<BorrowedBook>
+{
+    public void Define(IProjectionBuilderFor<BorrowedBook> builder) => builder
+        .From<BookBorrowed>(from => from
+            .Set(m => m.UserId).To(e => e.UserId)
+            .Set(m => m.Borrowed).ToEventContextProperty(c => c.Occurred))
+        .Join<BookAddedToInventory>(bookBuilder => bookBuilder
+            .On(m => m.Id)
+            .Set(m => m.Title).To(e => e.Title))
+        .Join<UserOnboarded>(userBuilder => userBuilder
+            .On(m => m.UserId)
+            .Set(m => m.User).To(e => e.Name))
+        .RemovedWith<BookReturned>();
+}
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/BorrowedBooksProjection.cs#L5-L22)
 
 With this projection, we specify that from the `BookBorrowed` event, we are interested in storing which user borrowed the book and the time it was borrowed.
 The time is derived from the `Occurred` property of the `EventContext`. For display purposes, we want to show the name of the book and the name of the user

Documentation/get-started/console.md

@@ -36,12 +36,27 @@ discover and register everything automatically.
 
 The following snippet configures the minimum and discovers everything for you:
 
-{{snippet:Quickstart-Console-Setup}}
+```csharp
+using Cratis.Chronicle;
+
+// Explicitly use the Chronicle Options to set the naming policy to camelCase for the projection/reducer sinks
+using var client = new ChronicleClient(ChronicleOptions.FromUrl("http://localhost:35000").WithCamelCaseNamingPolicy());
+var eventStore = await client.GetEventStore("Quickstart");
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Console/Program.cs#L11-L15)
 
 [!INCLUDE [common](./common.md)]
 
 [!INCLUDE [common](./mongodb.md)]
 
 With this you can query the collections as expected using the **MongoDB.Driver**:
 
-{{snippet:Quickstart-Books}}
+```csharp
+public class Books(IMongoCollection<Book> collection)
+{
+    public IEnumerable<Book> GetAll() => collection.Find(Builders<Book>.Filter.Empty).ToList();
+}
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/Books.cs#L9-L12)

Documentation/get-started/docker.md

@@ -14,4 +14,29 @@ docker run -d -p 27017:27017 -p 8080:8080 -p 35000:35000 cratis/chronicle:latest
 If you prefer to have a Docker Compose file, we recommend the following setup with Aspire to give
 you open telemetry data:
 
-{{snippet:Quickstart-DockerCompose}}
+```csharp
+services:
+  chronicle:
+    image: cratis/chronicle:latest-development
+    environment:
+      - OTEL_EXPORTER_OTLP_ENDPOINT=http://aspire-dashboard:18889
+    ports:
+      - 27017:27017
+      - 8080:8080
+      - 11111:11111
+      - 30000:30000
+      - 35000:35000
+
+  aspire-dashboard:
+    image: mcr.microsoft.com/dotnet/aspire-dashboard:latest
+    environment:
+      - DOTNET_DASHBOARD_UNSECURED_ALLOW_ANONYMOUS=true
+      - DOTNET_DASHBOARD_OTLP_ENDPOINT_URL=http://chronicle:18889
+      - ALLOW_UNSECURED_TRANSPORT=true
+      - DOTNET_ENVIRONMENT=Development
+    ports:
+      - 18888:18888
+      - 4317:18889
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/docker-compose.yml#L2-L23)

Documentation/get-started/mongodb.md

@@ -4,4 +4,19 @@ When leveraging the Reducer and Projection capabilities of Chronicle, your Mongo
 to match how it produces documents and naming conventions. By adding the following code, you'll have something that
 matches:
 
-{{snippet:Quickstart-MongoDBDefaults}}
+```csharp
+        BsonSerializer
+            .RegisterSerializer(new GuidSerializer(GuidRepresentation.Standard));
+
+        var pack = new ConventionPack
+        {
+            // We want to ignore extra elements that might be in the documents, Chronicle adds some metadata to the documents
+            new IgnoreExtraElementsConvention(true),
+
+            // Chronicle uses camelCase for element names, so we need to use this convention
+            new CamelCaseElementNameConvention()
+        };
+        ConventionRegistry.Register("conventions", pack, t => true);
+```
+
+[Snippet source](https://github.com/cratis/samples/blob/main/Chronicle/Quickstart/Common/MongoDBDefaults.cs#L16-L27)