es-as-mongodb - GitLite

KO | EN

gitlite — search

#reactjs #ruby #security #deep-learning #list #generative-ai #monitoring #hacktoberfest #framework #claude-code

es-as-mongodb

(★ 9)

Event Sorucing as MongoDB

File Explorer

ZIP Download

- - boundary-violations.json
  - co-changes.json
  - communities.json
  - drift-events.json
  - schema-version
- config.yaml
- - README.md
  - run-test.md
  - seed-reviews.md
  - seed-reviews.sh
  - seed.sh
  - setup-and-run.md
  - setup-run.sh
  - stop.sh
- Event-Sourcing.postman_collection.json
- eventstorming.png
- Review.EventStorming.md
- - Aggregate.cs
  - EventTypeMapper.cs
  - IAggregateStore.cs
  - Identity.cs
  - IRepository.cs
  - ISnapshotStore.cs
  - ISnapshottable.cs
  - Repository.cs
  - Reviews.Core.csproj
  - Snapshot.cs
  - Value.cs
- - CheckpointDocument.cs
  - EventDocument.cs
  - EventSerializer.cs
  - MongoAggregateStore.cs
  - MongoCheckpointStore.cs
  - MongoEventStoreSettings.cs
  - MongoProjectionManager.cs
  - MongoProjectionManagerBuilder.cs
  - MongoSnapshotStore.cs
  - Reviews.Core.Mongo.csproj
  - SnapshotDocument.cs
- - Exceptions.cs
  - History.cs
  - ProductId.cs
  - Review.cs
  - Reviews.Domain.csproj
  - ReviewSnapshot.cs
  - Status.cs
  - UserId.cs
- - ActiveReviewDocument.cs
  - Reviews.Service.Contract.csproj
  - ReviewsByOwnerDocument.cs
  - ReviewsByProductDocument.cs
- - appsettings.Development.json
  - appsettings.json
  - Program.cs
  - Reviews.Service.QueryApi.csproj
- - appsettings.Development.json
  - appsettings.json
  - EventMappings.cs
  - Program.cs
  - ReviewCommandEndpoints.cs
  - Reviews.Service.WebApi.csproj
- - AggregateStoreTests.cs
  - CheckpointStoreTests.cs
  - MongoTestFixture.cs
  - ProjectionManagerTests.cs
  - Reviews.Core.Mongo.Test.csproj
  - SnapshotStoreTests.cs
- - after_publish_review_snapshot_taken.cs
  - create_review.cs
  - review_approve.cs
  - review_published.cs
  - Reviews.Domain.Test.csproj
  - SpecificationAggregateStore.cs
  - Spesification.cs
  - update_review_content.cs
.gitignore
.mcp.json
CLAUDE.md
docker-compose.yaml
presentation.html
README.md
Reviews.Demo.sln
reviews.http

# Use via CDN

jsDelivr

jsDelivr serves any public GitHub repository as a CDN with zero setup. Pick a version and a file to get a ready-to-paste link and snippet.

Version

File

Link

Example

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

Hand-rolled event sourcing on .NET 8 with **MongoDB as both the event store and the read-model store**.
No event-sourcing framework  the patterns (aggregate store, snapshots, projection manager with
catch-up + change streams, optimistic concurrency) are implemented directly on `MongoDB.Driver`.

## Architecture

* **Write side** (`Reviews.Service.WebApi`): commands → `Review` aggregate → events appended to the
  `events` collection. Optimistic concurrency via a unique `{StreamId, Version}` index; global ordering
  via an atomic `counters` sequence. Snapshots in `snapshots`.
* **Projections** (`MongoProjectionManager`): per projection, catch-up by polling events after the stored
  checkpoint, then live via MongoDB **Change Streams**. Read models written to `activeReviews`,
  `reviewsByOwner`, `reviewsByProduct`. Checkpoints in `checkpoints` (last processed global position).
* **Read side** (`Reviews.Service.QueryApi`): queries the read-model collections directly.

```
src/
  Reviews.Core/             storage-agnostic ES primitives (Aggregate, Repository, interfaces, EventTypeMapper)
  Reviews.Domain/           Review aggregate, events, ReviewSnapshot
  Reviews.Core.Mongo/       MongoAggregateStore, MongoSnapshotStore, MongoCheckpointStore, MongoProjectionManager
  Reviews.Service.Contract/ read-model documents
  Reviews.Service.WebApi/   command Minimal API + projections + projection host
  Reviews.Service.QueryApi/ query Minimal API
tests/
  Reviews.Domain.Test/      domain behavior tests (no Mongo)
  Reviews.Core.Mongo.Test/  Mongo store + projection integration tests (need a running MongoDB)
```

## Prerequisites

* .NET 8 SDK
* Docker (for MongoDB single-node replica set  Change Streams require a replica set)

## Run

```Shell
docker compose -f docker-compose.yaml up -d        # MongoDB rs0 + mongo-express (http://localhost:8081)
dotnet run --project src/Reviews.Service.WebApi   --urls http://localhost:5080
dotnet run --project src/Reviews.Service.QueryApi --urls http://localhost:5081
```

Swagger: <http://localhost:5080/swagger> (commands) <http://localhost:5081/swagger> (queries).
\
\
MongoDB Management UI: <http://localhost:8081/>\
\
Sample flow (create → publish → approve → query): see [`reviews.http`](reviews.http).

Quick check with curl:

```Shell
ID=11111111-1111-1111-1111-111111111111
curl -X POST http://localhost:5080/reviews -H "Content-Type: application/json" \
  -d "{\"id\":\"$ID\",\"caption\":\"great\",\"content\":\"nice product\",\"owner\":\"22222222-2222-2222-2222-222222222222\",\"productId\":\"33333333-3333-3333-3333-333333333333\"}"
curl -X PUT http://localhost:5080/reviews/publish -H "Content-Type: application/json" -d "{\"id\":\"$ID\"}"
curl -X PUT http://localhost:5080/reviews/approve -H "Content-Type: application/json" \
  -d "{\"id\":\"$ID\",\"reviewer\":\"44444444-4444-4444-4444-444444444444\"}"
curl "http://localhost:5081/reviews/active?id=$ID"
```

The final query returns the approved review from the `activeReviews` read model (content uppercased),
proving the full write → events → change-stream projection → read-model path works on MongoDB.

## Test

```Shell
docker compose -f docker-compose.yaml up -d        # integration tests connect to this MongoDB
dotnet test Reviews.Demo.sln
```

Domain tests need no infrastructure; `Reviews.Core.Mongo.Test` connects to
`mongodb://localhost:27017/?replicaSet=rs0` (override with the `MONGO_TEST_CS` environment variable).

## Known limitations (demo scope)

These are intentional simplifications for a teaching demo, not production guidance:

* **Global-position gaps.** The global position comes from a `counters` sequence. Under concurrent writers
  a rare ordering gap is possible (writer A reserves position 5 but commits after writer B's position 6);
  a poller could then advance its checkpoint past 5. Production options: serialize appends via a single
  writer/outbox, or make the change stream the single source of truth with resume-token checkpoints. The
  polling catch-up path is also what recovers beyond the MongoDB oplog retention window
  (change-stream resume only works while the resume token stays within the oplog).
* **No authentication/authorization.** The query endpoints (e.g. `/reviews/active/user-id?user_id=...`)
  accept identifiers straight from the query string with no auth  an IDOR by design for the demo. In
  production, protect endpoints (`.RequireAuthorization()`) and derive `user_id` from the authenticated
  `ClaimsPrincipal` rather than trusting the caller.
* **Snapshot version lag.** `ReviewSnapshot` is captured with the aggregate's pre-append version, so a
  snapshot can report a lower `Version` than the event it reflects, causing a double-apply if the aggregate
  is later rehydrated via the snapshot path. Inherited from the original demo; the happy-path read flow uses
  projections, not snapshot rehydration. A production fix increments the version on apply (or snapshots
  `Version + uncommitted change count`).
* **Single-node replica set, no clustering, no event versioning/upcasting.**