jet/dotnet-templates

This system is a comprehensive library and template suite for building event-sourced .NET applications using the Equinox and Propulsion frameworks. It provides a collection of ready-to-use project templates that implement common architectural patterns, including reactive processing, data indexing, and stream consumption. The system supports multiple storage backends such as Cosmos DB, DynamoDB, and Kafka, enabling developers to quickly scaffold services for data ingestion, state management, and event projection.

14 changes.

This period focused on upgrading the codebase to .NET 8/10 and integrating Equinox 4 and Propulsion 3, which introduced new APIs for handling commands, queries, and serialization. The team expanded the template library with new tools for event sourcing, including Kafka consumers, projectors, and sync utilities, while refactoring existing web and domain layers to support multiple storage backends.

12 changes.

This period focused on expanding the framework's capabilities by introducing numerous new templates for event sourcing and processing, including the Propulsion reactor, archiver, pruner, and indexer, as well as the Equinox shipping and hotel samples. The work emphasized multi-source and multi-target support across various storage backends like Cosmos DB, DynamoDB, and Kafka, while also adding infrastructure for AWS CDK and integration tests to ensure template reliability.

This change introduces new AWS CDK (Cloud Development Kit) templates that define the infrastructure for the Propulsion DynamoStore components. Specifically, it adds an \IndexerStack\ to deploy a Lambda function that indexes DynamoDB Stream events, and a \NotifierStack\ to deploy a Lambda function that publishes index updates to an SNS topic. The project includes the necessary F\# source files (\IndexerStack.fs\, \NotifierStack.fs\, \Program.fs\) and configuration (\cdk.json\, \template.json\) to manage these AWS resources via CDK.

propulsion-dynamostore-cdk · high confidence

Introduces the 'Equinox Patterns' sample template, providing a suite of domain primitives for event sourcing. This includes a \Period\ implementation that manages rolling balances carried forward between periods, and an \ExactlyOnceIngester\ that guarantees each item is inserted into a chain of \ListEpoch\s exactly once. The template also includes a \ListSeries\ to track the active epoch and an \Accumulator\ for buffering and applying events. Tests are provided for the \ExactlyOnceIngester\ and \Period\ logic.

equinox-patterns · high confidence

Introduces the 'Equinox Shipping' sample project, providing a complete example of an event-sourced process manager that manages the enlistment of Shipment aggregates into a Container aggregate. The change adds the domain model (Container, FinalizationProcess, Shipment, TransactionWatchdog) and their corresponding unit tests. It also includes integration test fixtures for Cosmos, DynamoDB, and EventStoreDB, along with a Watchdog console application to handle stuck or abandoned transactions.

equinox-shipping · high confidence

Introduces a new \feed-consumer\ template that provides a ready-to-use F\# project for consuming event streams from an external HTTP API. The template includes an \ApiClient\ to fetch data pages and tranches, an \Ingester\ to process and deduplicate items, and a \Program\ that wires up the Propulsion feed source and Equinox/Propulsion metrics sinks. It supports command-line arguments for Cosmos DB configuration, parallelism settings, and verbose logging.

feed-consumer · high confidence

Introduces a new \PeriodicIngester\ template for F\# projects, providing a ready-to-use implementation for periodic data ingestion. The template includes an HTTP client for crawling source datasets, infrastructure for logging and metrics (including Prometheus integration), and a pipeline for ingesting events into a store. It also defines domain types and utility modules for handling ticket data and ingestion outcomes.

periodic-ingester · high confidence

The propulsion-hotel area introduces a new sample template demonstrating a Reactor and Process Manager pattern using Equinox and Propulsion. This includes the domain model for GuestStay and GroupCheckout aggregates, a Reactor host project, and integration tests for DynamoDB and MessageDB backends. The template allows users to generate a solution that illustrates how to implement reactive processing where a background process (Reactor) drives behavior across multiple aggregates (GuestStay and GroupCheckout) via event sourcing.

propulsion-hotel · high confidence

Introduced a new \proConsumer\ .NET template for generating F\# Kafka consumers using the Propulsion and Equinox frameworks. The template includes a \template.json\ configuration, an \Examples.fs\ file demonstrating multi-stream processing with in-memory state management, an \Infrastructure.fs\ file providing helper modules for logging and semaphore throttling, and a \Program.fs\ entry point that parses command-line arguments and starts the consumer. A \README.md\ provides usage instructions for running the generated consumer.

propulsion-consumer · high confidence

The \propulsion-sync\ template is introduced, providing a new capability to replicate data from a Cosmos DB or EventStoreDB source to a Cosmos DB or EventStoreDB destination. The implementation includes \Infrastructure.fs\ for logging and store connectors, \Program.fs\ for argument parsing and orchestration, and a \README.md\ with usage instructions. Users can now deploy this template to sync data between these storage systems, supporting features like verbose logging, batch size configuration, and category filtering.

propulsion-sync · high confidence

Introduces a new \propulsion-archiver\ module containing a template for archiving data from a Cosmos DB container to a secondary container. The implementation includes a \Handler\ that filters change feed events by category, an \Infrastructure\ module for logging and metrics wiring (including Prometheus integration), and a \Program\ that sets up the source (Cosmos DB change feed) and sink (Cosmos DB writes) with configurable parameters like read-ahead, writer concurrency, and lag reporting frequency.

propulsion-archiver · high confidence

Introduced a new F\# template for a Propulsion-based tracking consumer that ingests Kafka messages and syncs summaries to Azure Cosmos DB. The template includes infrastructure for logging, a Kafka ingester, and a SkuSummary service that manages item state using Equinox deciders.

propulsion-tracking-consumer · high confidence

Introduces a new 'Equinox Feed Source' template that provides a complete domain model and API for ingesting and reading ticket data. The domain layer defines aggregates for tracking ticket epochs and series, with an ingester service that handles idempotent, deduplicated ingestion into a chain of epochs. The FeedApi layer exposes HTTP endpoints to post new tickets, list active tranches, and read historical ticket data. Infrastructure code configures Serilog sinks for Prometheus metrics and sets up dependency injection for the domain services.

feed-source · high confidence

The Domain layer for the C\# Equinox web template has been introduced, providing the core domain model and infrastructure. This includes the Aggregate base class defining event encoding/decoding and state folding, the ClientId type for stream identification, a System.Text.Json-based codec for binary serialization, and the Todo aggregate with its specific events (Added, Updated, Deleted, Cleared, Snapshotted) and commands (Add, Update, Delete, Clear). The implementation maps commands to events and maintains state, enabling the web application to interact with the Equinox event sourcing framework.

equinox-web-csharp/Domain · high confidence

The equinox-testbed area now provides a new \eqxtestbed\ template that generates a load-testing harness for Equinox. The generated project includes a CLI interface (Program.fs) that supports running against three different backends: an in-memory store, EventStore, or Azure Cosmos DB. The template wires up the appropriate storage configuration (Storage.fs), service layer (Services.fs), and domain logic (Store.fs) based on compile-time flags, allowing users to benchmark and test their domain models against different storage providers.

equinox-testbed · high confidence

Adds a new \propulsion-indexer\ template that enables indexing and summarizing data from a Cosmos DB change feed. The implementation includes argument parsing for connection and filtering, a \CosmosDumpSource\ for file-based processing, and domain logic for ingesting and snapshotting Todo list events. It wires up the Propulsion reactor pattern to transform source events into a summary index, with dedicated modules for metrics, logging, and stream filtering.

propulsion-indexer · high confidence

Adds a new summary consumer implementation that consumes Kafka events and maintains a Cosmos DB-backed summary state. The change introduces the core infrastructure for reading, decoding, and processing event streams, including a new \TodoSummary\ aggregate, an \Ingester\ for handling incoming updates, and a \Program\ entry point that configures Kafka consumption and CosmosDB storage. This provides a reusable template for building summary consumers using the Propulsion framework.

propulsion-summary-consumer · high confidence

Added the proProjector template, which generates a .NET console application for building event projection pipelines. The template supports multiple source stores (CosmosDB, DynamoDB, EventStoreDB, SqlStreamStore) and optional Kafka sinks, allowing users to project events from various backends to Kafka topics or process them locally. The generated code includes argument parsing, infrastructure for connecting to the selected stores, and handler logic for processing events.

propulsion-projector · high confidence

A new \propulsion-pruner\ application has been added to provide automated pruning of expired events from a CosmosDB container. The tool connects to a source container to read the change feed, filters events based on category and age (defaulting to 30 days), and deletes them from the primary container. It supports configurable read-ahead, writer concurrency, and exposes Prometheus metrics for monitoring the pruning process.

propulsion-pruner · high confidence

The \propulsion-reactor\ template now supports multiple event sources (CosmosDB, DynamoDB, EventStore, SQL Server, and Kafka) and multiple output targets (CosmosDB, DynamoDB, and Kafka). Users can select their preferred source and sink via command-line arguments or project template parameters, enabling flexible event processing pipelines across different storage backends.

propulsion-reactor · high confidence

The project has been updated to target .NET 8 (net8.0) and upgraded to Equinox 4.0.0, Propulsion 3.0.0, and FsCodec 3.0.0. A new \proIndexer\ template has been added, which extends the \proCosmosReactor\ to maintain a summarized form of an Aggregate's state as \RollingState\ in a separated \Views\ Container, with \snapshot\ and \sync\ subcommands. The \proCosmosReactor\ template has been split to become \proIndexer\. Additionally, the \eqxShipping\ template has been updated to clarify reactor logic by removing the \isValidTransition\ anti-pattern, and the \Argu\ library has been updated to version 6.0.14.

(repo-wide) · high confidence

The C\# web application template has been ported to use Equinox 4 and Propulsion 3, updating the underlying event sourcing and persistence abstractions. This includes new implementations for \EquinoxContext\ and specific store contexts (Cosmos, EventStore, Memory) that integrate with the updated libraries, along with corresponding updates to the \Startup\ and \Program\ classes to support the new architecture.

equinox-web-csharp/Web · high confidence

The Web project has been refactored to support multiple storage backends (Memory, EventStore, Cosmos, and DynamoDB) via conditional compilation symbols, replacing the previous single-memory-store default. Logging has been restructured to use a shared extension method for Serilog configuration, which now conditionally writes to Prometheus sinks for Cosmos and DynamoDB stores. The template also introduces an Aggregate example alongside the existing Todo example, and updates the hosting entry point to use the new logging configuration.

equinox-web/Web · high confidence

The Todo domain has been refactored to align with Equinox 4 and Propulsion 3. The \ClientId\ type has been replaced with a strongly-typed \Guid\<clientId\>\ from the \FSharp.UMX\ library. The \Todo\ and \Aggregate\ modules now use the \Equinox.Decider\ API for handling commands and queries, replacing the previous \Equinox.Handler\ and \Commands\ pattern. The \Store\ module now provides factory methods for various backends (Memory, Cosmos, Dynamo, EventStore) using \FsCodec\ for serialization. The \TodosService\ and \ClientId\ files have been removed as their functionality has been integrated into the new \Todo\ and \Aggregate\ modules.

equinox-web/Domain · medium confidence

The Equinox Web template solution has been reorganized to include a dedicated 'Domain' project, separating domain logic from the web layer. The solution file now references the new Domain project and includes the README, while removing the previous Backend project configuration.

equinox-web · high confidence

The TodosController has been updated to use the new Equinox 4 and FsCodec 3 APIs. This includes switching the namespace from TodoBackend to TodoBackendTemplate, updating the service method calls (e.g., service.Delete, service.Clear), and adjusting the controller's internal member references to use 'this' instead of '\\'.

equinox-web/Web/Controllers · medium confidence

Added new integration tests in the tests directory that verify the build and generation of all Equinox templates, including proProjector, proReactor, eqxweb, proIndexer, and others, ensuring each template can be instantiated and built successfully.

tests · high confidence

The project has been upgraded to use Equinox 4.1.0 and Propulsion 3.0.0, along with FsCodec 3.1.0. This update targets .NET 6.0 for most domain and web projects, while test and integration projects target .NET 10.0. Key dependencies such as \Equinox.CosmosStore\, \Propulsion.DynamoStore\, and \xunit.v3.mtp-v2\ have been updated to their latest versions, and the codebase has been migrated to use the new \Equinox.\\ and \Propulsion.\\ package naming conventions.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 64 → 64 (-0.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 63 → 62 (-0.5)
• Architecture 71 → 71 (+0.1)
• Maturity 60 → 60 (+0.0)
• Readiness 95 → 94 (-0.4)
• Security 63 → 61 (-2.0)
• Domain Modelling 100 → 100 (-0.2)
• Performance 83 → 83 (+0.0)

• Duplicated block (10 lines × 2) (equinox-web/Domain/Aggregate.fs)
• Duplicated block (10 lines × 2) (feed-consumer/Infrastructure.fs)
• Duplicated block (10 lines × 2) (feed-consumer/Program.fs)
• Duplicated block (10 lines × 2) (propulsion-projector/SourceArgs.fs)
• Duplicated block (10 lines × 2) (propulsion-pruner/Program.fs)
• Duplicated block (10 lines × 2) (propulsion-reactor/Todo.fs)
• Duplicated block (10 lines × 4) (equinox-testbed/Store.fs)
• Duplicated block (10 lines × 4) (propulsion-projector/Args.fs)
• Duplicated block (10 lines × 4) (propulsion-projector/Infrastructure.fs)
• Duplicated block (10 lines × 4) (propulsion-reactor/Store.fs)
• Duplicated block (11 lines × 2) (feed-consumer/Infrastructure.fs)
• Duplicated block (11 lines × 2) (propulsion-archiver/Program.fs)
• Duplicated block (11 lines × 2) (propulsion-reactor/SourceConfig.fs)
• Duplicated block (11 lines × 3) (propulsion-projector/Args.fs)
• Duplicated block (11 lines × 3) (propulsion-reactor/TodoSummary.fs)
• Duplicated block (11 lines × 6) (feed-consumer/Infrastructure.fs)
• Duplicated block (12 lines × 2) (propulsion-archiver/Program.fs)
• Duplicated block (12 lines × 2) (propulsion-reactor/SourceConfig.fs)
• Duplicated block (12 lines × 2) (propulsion-reactor/Todo.fs)
• Duplicated block (12 lines × 2) (propulsion-reactor/Todo.fs)
• …and 99 more

• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (equinox-web/Domain/Todo.fs)
• Duplicated block (10 lines × 2) (propulsion-sync/Program.fs)
• Duplicated block (10 lines × 3) (equinox-shipping/Watchdog/Args.fs)
• Duplicated block (10 lines × 3) (propulsion-consumer/Program.fs)
• Duplicated block (10 lines × 4) (equinox-shipping/Watchdog/Infrastructure.fs)
• Duplicated block (10–11 lines × 2) (equinox-web/Domain/Store.fs)
• Duplicated block (10–11 lines × 2) (feed-consumer/Infrastructure.fs)
• Duplicated block (10–11 lines × 3) (equinox-shipping/Watchdog/Args.fs)
• Duplicated block (10–11 lines × 3) (equinox-shipping/Watchdog/SourceArgs.fs)
• Duplicated block (10–11 lines × 4) (equinox-patterns/Domain/Store.fs)
• Duplicated block (10–11 lines × 4) (equinox-shipping/Watchdog/SourceArgs.fs)
• Duplicated block (11 lines × 2) (equinox-shipping/Watchdog/SourceConfig.fs)
• Duplicated block (11 lines × 2) (propulsion-summary-consumer/Program.fs)
• Duplicated block (11 lines × 3) (propulsion-indexer/Domain/TodoIndex.fs)
• Duplicated block (11 lines × 6) (equinox-shipping/Watchdog/Args.fs)
• Duplicated block (11 lines × 6) (feed-consumer/Infrastructure.fs)
• Duplicated block (11–13 lines × 4) (equinox-shipping/Watchdog/Infrastructure.fs)
• …and 167 more

• Unchanged — 6 HTTP endpoints

• Containers 1 added · 0 removed · contexts 14 added · 0 removed · edges 2 added · 0 removed

• web-api:Web

• Consumer
• FeedApi
• FeedConsumer
• PeriodicIngester
• Projector
• Reactor
• SummaryConsumer
• Sync
• Testbed
• TodoBackendTemplate
• TodoBackendTemplate.Controllers
• TrackingConsumer
• Watchdog
• Watchdog.Integration

• TodoBackendTemplate.Controllers → TodoBackendTemplate (coupling)
• Watchdog.Integration → Watchdog

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

jet/dotnet-templates was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.