oskardudycz/GoldenEye

GoldenEye is a .NET 6-based framework that provides infrastructure for building event-driven, domain-driven applications. It offers a modular architecture supporting command and event buses, along with multiple repository implementations for databases like PostgreSQL, MSSQL, and ElasticSearch, as well as event sourcing via Marten. The system also includes Kafka integration for event streaming and standardized Web API middleware for exception handling.

8 changes.

The project underwent a significant modernization by upgrading to .NET 6 and adopting a new SDK-style project structure. This period focused on removing obsolete dependencies, legacy code, and outdated configuration files to streamline the codebase.

23 changes.

This period focused on establishing a comprehensive domain-driven architecture by introducing core abstractions for commands, events, and aggregates. The team implemented multiple storage backends, including Dapper, Entity Framework, Marten, and ElasticSearch, alongside Kafka integration. Extensive testing infrastructure was added to validate these components and the overall event-driven workflow.

A new sample project demonstrating a Cinema Tickets Reservations application using Marten for event sourcing and CQRS patterns. The sample includes a solution file defining projects for Core, Tickets, Tickets.Api, and associated test projects, alongside a README with setup instructions for Postgres via Docker.

samples/DDD/Tickets · high confidence

The sample application now includes a complete WebAPI project structure, providing a functional starting point for developers. This includes a ValuesController with standard CRUD endpoints, a Program entry point using WebHostBuilder, a Startup class for dependency injection and middleware configuration, and configuration files (appsettings.json) for logging and environment-specific settings.

samples/GoldenEye.WebApi.Sample · high confidence

Introduced a new Dapper-based repository implementation that supports both automatic SQL generation via conventions and custom SQL mappings through the new IDapperMapping interface and IDapperSqlGenerator abstraction. The DapperRepository class now integrates with an aggregate events publisher to automatically enqueue domain events, and includes a registration extension AddAllDapperMappings for automatic DI scanning of custom SQL mappings.

src/Dapper/Dapper · high confidence

A new docker-compose.yml file and environment variable files for PostgreSQL and Microsoft SQL Server have been added to the project. This enables local development and integration testing against these specific database engines, each configured with their respective ports (5432 for PostgreSQL, 1433 for MSSQL) and environment variables.

docker · high confidence

The ElasticSearch module now includes a concrete \ElasticSearchRepository\ class that implements the standard repository interface, enabling CRUD operations (FindById, Add, Update, Delete) against an ElasticSearch instance. The implementation supports string, int, long, and Guid entity IDs and includes an event publisher for saving changes. Additionally, the module's Changelog and Readme files have been added to document version history and usage instructions.

src/ElasticSearch · high confidence

Users can now integrate with Apache Kafka for event streaming. The update introduces \KafkaProducer\ and \KafkaConsumer\ classes, along with their configuration models (\KafkaProducerConfig\, \KafkaConsumerConfig\) and extension methods for dependency injection registration (\AddKafkaProducer\, \AddKafkaConsumer\). This enables publishing and consuming external events via Kafka topics, configurable through \appsettings.json\.

src/Kafka · high confidence

Introduced the Tickets.Api sample application, providing a RESTful API for managing concert and seat information, as well as handling reservation workflows. The new controllers expose endpoints for creating, retrieving, and modifying tentatively held reservations, including seat changes and confirmations. Additionally, a maintenance endpoint allows for rebuilding database projections, supporting the underlying event-sourced architecture.

samples/DDD/Tickets/Tickets.Api · high confidence

The WebApi project now includes an exception handling middleware that automatically catches unhandled exceptions and maps them to appropriate HTTP status codes (e.g., BadRequest, Unauthorized, NotFound) with consistent JSON error responses. This is supported by an \ExceptionToHttpStatusMapper\ that handles various exception types and allows for custom mappings. Additionally, base controller classes (\ReadonlyControllerBase\, \RestControllerBase\) and module registration helpers have been added to streamline Web API development.

src/WebApi · high confidence

The Tickets sample now includes a complete domain model for managing concerts, seats, and ticket reservations. Users can create, confirm, and cancel reservations, as well as change seats. The system tracks reservation status (Tentative, Confirmed, Cancelled) and provides queries to retrieve reservation details, history, and lists. This adds the core business logic for the ticketing workflow.

samples/DDD/Tickets/Tickets · high confidence

The repository was initialized with essential configuration files, including a .gitattributes file to manage line endings and diff behavior, a .gitignore file to exclude build artifacts and IDE-specific files, and a LICENSE.txt file establishing the MIT license. Additionally, a README.md was added to describe the GoldenEye framework, and a docker-compose.yml file was introduced to orchestrate local development environments for Postgres, MSSQL, EventStore, and Elasticsearch. The old solution file (THB.ClientPortal.sln) was removed as part of this initial setup.

(repo-wide) · high confidence

Added new implementations for event-sourced and document-based repositories using Marten, including \MartenEventStore\, \MartenDocumentRepository\, and \MartenEventSourcedRepository\. These classes provide the underlying storage and query capabilities for the GoldenEye framework, supporting optimistic concurrency via version checks and integrating with the \IAggregateEventsPublisher\ for event publishing. The changes also include integration tests and configuration helpers to bootstrap the Marten document store and register the repositories in the DI container.

src/Marten · high confidence

Added foundational types for the command and event bus patterns, including \ICommand\, \ICommandBus\, \IEventBus\, and \IEventHandler\ interfaces, alongside their concrete implementations like \CommandBus\ and \EventBus\. The change also introduces the \IAggregate\ and \Aggregate\ base classes to support event-sourced domain models, along with an \AggregateEventsPublisher\ to manage uncommitted events. Additionally, the update adds \AuditableEntity\ and related save-change handlers to automatically track creation and modification metadata on entities.

src/Core/Core · high confidence

Added a new .editorconfig file in the src directory to enforce consistent C\# coding conventions, formatting, and style rules across the codebase. This includes settings for indentation, whitespace, null propagation, expression-bodied members, and naming conventions, ensuring that all developers follow the same code style guidelines.

src · high confidence

The application has removed the legacy ASP.NET MVC startup configuration files, including \BundleConfig.cs\, \IdentityConfig.cs\, \RouteConfig.cs\, \Startup.Auth.cs\, and \WebApiConfig.cs\. This change eliminates the old bundling, routing, identity, and Web API setup logic, likely as part of a migration to a modernized architecture or framework.

THB.ClientPortal · high confidence

The Shared.Core module has been cleaned up by removing the jQuery 1.4.1 JavaScript files (including the minified, unminified, and VS doc versions) as well as obsolete C\# interfaces and classes (IDTO, DTOBase, IHasId, and AssemblyInfo). This removes outdated client-side dependencies and unused server-side abstractions from the codebase.

Shared.Core · high confidence

The Backend.Core module removed the legacy jQuery 1.4.1 client-side scripts (including the minified and VS-Documented versions) from the project. Additionally, the codebase removed the Entity Framework-based data access layer, specifically the \DataContext\ and \IDataContext\ interfaces, as well as the \BaseRepository\ and \IRepository\ abstractions. These changes indicate a significant architectural shift away from the previous data access and client-side scripting implementations.

Backend.Core · high confidence

The Backend.Business project has been cleaned up by removing the legacy jQuery 1.4.1 library files (jquery-1.4.1.js, jquery-1.4.1.min.js, and their IntelliSense documentation). Additionally, the TaskRepository class, the Backend.Business.csproj.user configuration file, and the AssemblyInfo.cs metadata file have been deleted, indicating a removal of unused or outdated components from the backend business layer.

Backend.Business · high confidence

Added Entity Framework integration tests and migration infrastructure; Added acceptance tests for creating tentative reservations; Added base test infrastructure for Dapper integration tests; Added integration tests for Dapper repository CRUD operations; Added test data for Dapper integration tests; Added test suite for ticket reservation domain; Added testing utilities for DDD and event-driven architectures; Added tests for Dapper mapping registration; Added tests for command, event, and query handler registration; Added tests for event store pipeline and function memoization; Added tests for module registration; Added tests for the validation pipeline; Removed unused Bootstrap theme assets from the test project.

The codebase has been upgraded to target .NET 6, replacing the previous .NET Framework 4.5 projects. This change introduces a modernized project structure with new .csproj files for core libraries (Core, Dapper, EntityFramework, Marten, Kafka, ElasticSearch, WebApi) and their corresponding test projects. The old-style \packages.config\ files and legacy project files (such as \Backend.Business\, \Backend.Core\, and \Shared.Core\) have been removed in favor of the new SDK-style project definitions.

(dependencies) · high confidence

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

• CAI 55 → 49 (-6.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 72 → 72 (-0.0)
• Architecture 94 → 94 (+0.0)
• Maturity 53 → 53 (+0.0)
• Readiness 50 → 40 (-9.9)
• Security 79 → 74 (-4.6)
• Domain Modelling 63 → 49 (-14.2)
• Event-Driven 100 → 100 (+0.0)
• Event Sourcing 100 → 100 (+0.0)
• Performance 54 → 54 (+0.0)

• Bounded contexts not declared
• Change coupling: MartenDocumentRepository.cs ↔ MartenEventSourcedRepository.cs (src/Marten/Marten/Repositories/MartenDocumentRepository.cs)
• High: security finding (details withheld)
• High: security finding (details withheld)
• LLM evaluation failed
• No exposed public API
• dormant codebase — no living knowledge left to concentrate

• Documentation: no installation or build instructions (README.md)
• Duplicated block (25 lines × 2) (src/Core/Core/Extensions/Lambda/ExpressionExtensions.cs)
• End-of-life runtime: .NET net6.0
• High IaC: WD-COMPOSE-0002 (docker-compose.ci.yml)
• High IaC: WD-COMPOSE-0002 (docker-compose.pg.yml)
• High IaC: WD-COMPOSE-0002 (docker-compose.pg.yml)
• High IaC: WD-COMPOSE-0002 (docker-compose.yml)
• High IaC: WD-COMPOSE-0002 (docker-compose.yml)
• High IaC: WD-COMPOSE-0002 (docker-compose.yml)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Leaked secret: hardcoded-credential (docker/mssql/variables.env)
• Leaked secret: hardcoded-credential (docker/postgres/variables.env)
• Low XML-doc coverage: Core (src/Core/Core/Core.csproj)
• Low XML-doc coverage: Dapper (src/Dapper/Dapper/Dapper.csproj)
• Low XML-doc coverage: ElasticSearch (src/ElasticSearch/ElasticSearch/ElasticSearch.csproj)
• Low XML-doc coverage: EntityFramework (src/EntityFramework/EntityFramework/EntityFramework.csproj)
• Low XML-doc coverage: GoldenEye.WebApi.Sample (samples/GoldenEye.WebApi.Sample/GoldenEye.WebApi.Sample.csproj)
• Low XML-doc coverage: Kafka (src/Kafka/Kafka/Kafka.csproj)
• Low XML-doc coverage: Marten(net6.0) (src/Marten/Marten/Marten.csproj)
• …and 22 more

• Unchanged — 14 HTTP endpoints

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

oskardudycz/GoldenEye 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.