ThembisileNGQ/Akkatecture

Akkatecture is an event-sourcing framework built on Akka.NET that provides infrastructure for managing aggregate roots, sagas, and persistent job scheduling. It supports distributed deployments through Akka Cluster Sharding and Singletons, enabling scalable handling of domain events and long-running processes across multiple nodes. The system includes built-in capabilities for snapshotting, event versioning with upcasting, and automated dependency injection integration.

59 changes.

This period marks the initial release of the Akkatecture event-sourcing framework, establishing core capabilities for aggregates, sagas, and event versioning. The work expanded the system with distributed clustering infrastructure via Akka Cluster Sharding and introduced integration with ASP.NET Core and dependency injection. Comprehensive test coverage and example applications were added to validate the new architecture and demonstrate usage patterns.

14 changes.

The project migrated its build infrastructure to a FAKE-based system with Azure Pipelines integration while introducing a persistent job scheduling framework and event-sourcing query consumers. Significant effort was also directed toward enhancing the testing ecosystem, including new aggregate fixtures, saga helpers, and multi-node cluster test runners.

Added a new sample application in examples/jobs that demonstrates how to schedule and run persistent jobs using Akkatecture. The sample includes a console application that configures a JobManager, defines a PrintJob with a corresponding scheduler and runner, and schedules a repeated job to execute every 10 seconds, logging the job content to the console.

examples/jobs · high confidence

The example API now includes a new domain aggregate for managing resources, consisting of the Resource aggregate root, ResourceId value object, ResourceState, and ResourceManager. This addition introduces the structural foundation for handling resource-related commands and events within the application's domain model.

examples/web/Akkatecture.Examples.Api/Domain/Aggregates/Resource · high confidence

Introduced \TestKitExtensions\ in the \Akkatecture.TestFixture\ library, providing \FixtureFor\ extension methods on \TestKitBase\. These methods allow users to easily create \IFixtureArranger\ instances for aggregates and aggregate managers, streamlining the setup of test fixtures for \ReceivePersistentActor\ and \ReceiveActor\ components within the Akkatecture framework.

src/Akkatecture.TestFixture/Extensions · high confidence

The simple example project now includes a complete UserAccount domain model, featuring a UserAccountAggregate that handles Create and ChangeName commands, a UserAccountState that tracks the account name, and corresponding UserAccountCreatedEvent and UserAccountNameChangedEvent classes.

examples/simple/Akkatecture.Examples.Domain/Model/UserAccount · high confidence

The example domain now includes \CreateUserAccountCommand\ and \UserAccountChangeNameCommand\ classes within the \Akkatecture.Examples.Domain.Model.UserAccount.Commands\ namespace. These commands inherit from the framework's \Command\ base class and allow users to specify a name when creating a new account or updating an existing one.

examples/simple/Akkatecture.Examples.Domain/Model/UserAccount/Commands · high confidence

The snapshotting system now supports three distinct strategies for determining when to create snapshots: \SnapshotAlwaysStrategy\ (creates a snapshot for every event), \SnapshotNeverStrategy\ (disables snapshotting), and \SnapshotEveryFewVersionsStrategy\ (creates a snapshot after a configurable number of versions, defaulting to 50). This allows users to tailor snapshot frequency to their performance and storage requirements.

src/Akkatecture/Aggregates/Snapshot/Strategies · high confidence

The library now includes a default configuration file (default.conf) and a corresponding settings class (AkkatectureClusteringDefaultSettings) to bootstrap Akka.NET cluster sharding. This sets up the cluster actor ref provider, defines serializers for JSON and cluster/sharding messages, and configures cluster timing parameters such as heartbeat intervals and gossip settings, allowing users to run cluster-enabled Akkatecture applications with sensible defaults.

src/Akkatecture.Clustering/Configuration · high confidence

The example API now includes queryable read models for tracking background work. New files in the \Domain/Repositories\ directory define \OperationsProjection\ and \ResourcesProjection\ classes, along with their corresponding storage handlers (\OperationsStorageHandler\, \ResourcesStorageHandler\) and query handlers (\OperationsQueryHandler\, \ResourcesQueryHandler\). The storage handlers subscribe to \ResourceCreationSaga\ events to maintain in-memory state, while the query handlers expose \Find\ and \FindAll\ methods to retrieve this data.

examples/web/Akkatecture.Examples.Api/Domain/Repositories · high confidence

The example API now includes a CreateResourceCommand and its handler for the Resource aggregate. When a new resource is created, the command emits a ResourceCreatedEvent and returns a SuccessExecutionResult to the sender. If the resource already exists, the command returns a FailedExecutionResult with an error message, ensuring users receive clear feedback on the outcome of the creation attempt.

examples/web/Akkatecture.Examples.Api/Domain/Aggregates/Resource/Commands · high confidence

The example API now includes a complete saga implementation for tracking the creation of a resource. This adds the \ResourceCreationSaga\ along with its associated state, ID, locator, manager, and domain events (\ResourceCreationStartedEvent\, \ResourceCreationProgressEvent\, \ResourceCreationEndedEvent\), demonstrating how to model a long-running process within the Akkatecture framework.

examples/web/Akkatecture.Examples.Api/Domain/Sagas · high confidence

The example application now includes a Program.cs entry point that demonstrates how to initialize an Akka actor system, create a supervising aggregate manager for the UserAccount aggregate, and execute sample commands (CreateUserAccountCommand and UserAccountChangeNameCommand) to interact with the domain model.

examples/simple/Akkatecture.Examples.Application · high confidence

The library now includes a specification pattern in the \Akkatecture.Specifications\ namespace, providing the \ISpecification\<T\>\ interface and an abstract \Specification\<T\>\ base class. This allows users to define reusable validation rules against domain objects (such as aggregates) and retrieve both boolean satisfaction results and human-readable reasons for failure, facilitating cleaner validation logic in application services.

src/Akkatecture/Specifications · high confidence

A new TypeExtensions class has been added to the clustering library to facilitate the reflection-based discovery of event subscriptions. It provides methods to identify which domain events a type subscribes to by inspecting implemented interfaces, specifically supporting both synchronous (ISagaHandles, ISubscribeTo) and asynchronous (ISagaHandlesAsync, ISubscribeToAsync) subscription patterns for sagas and general subscribers.

src/Akkatecture.Clustering/Extentions · high confidence

The event handling pipeline in src/Akkatecture/Events now supports schema evolution and cleaner event exposure. Users can annotate events with EventVersionAttribute and manage definitions via EventDefinitionService, while AggregateEventUpcaster provides a typed mechanism to transform older event versions into current ones during read operations. Additionally, DomainEventReadAdapter and DomainEventMapper automatically convert internal CommittedEvent wrappers into DomainEvent envelopes for queries, and AggregateEventTagger ensures events are tagged with aggregate names and definitions before being persisted to the journal.

src/Akkatecture/Events · high confidence

The API example now includes a set of new controllers that expose endpoints for managing resources and tracking their processing status. A new \BaseController\ provides helper methods for generating absolute URIs and handling 303 See Other redirects. The \ResourceController\ allows users to create resources via POST (returning 202 Accepted with Location headers), list all resources, and retrieve individual resources. The \OperationsController\ enables users to list operations and check the status of a specific operation by ID, automatically redirecting to the resource endpoint once the operation reaches 100% completion.

examples/web/Akkatecture.Examples.Api/Controllers · high confidence

The \Akkatecture.Examples.Api\ project has been introduced as a new web application demonstrating the framework's capabilities. It is built on ASP.NET Core and configured to listen on port 5001. The application initializes an Akka.NET actor system and registers key components—specifically the \ResourceManager\, \ResourceCreationSagaManager\, \ResourcesStorageHandler\, and \OperationsStorageHandler\—as dependency-injection providers. It also sets up MVC routing under the \/api\ path and includes a domain event definition for \ResourceCreated\.

examples/web/Akkatecture.Examples.Api · high confidence

This change introduces the core Akkatecture library, providing a foundation for building event-sourced applications on Akka.NET. It adds the \AggregateRoot\ and \AggregateSaga\ base classes for managing persistent state and long-running processes, along with supporting types for identities (\EventId\, \CommandId\, \SourceId\), snapshots, and definitions. The release also includes a job scheduling subsystem with commands for one-time, recurring, and cron-based tasks, as well as interfaces and value objects for aggregates and sagas.

Akkatecture · high confidence

This change introduces the foundational building blocks for the saga pattern within the Akkatecture framework. It adds core interfaces such as ISaga, ISagaId, and ISagaName to define saga identities and naming, along with ISagaHandles and ISagaIsStartedBy to specify how sagas react to and are triggered by domain events. Additionally, it provides the SagaId base class for implementing saga identifiers, the SagaNameAttribute for declarative naming, and the SagaState abstract class to manage saga state and message application, establishing the structural basis for saga implementations.

src/Akkatecture/Sagas · high confidence

This change adds the core infrastructure for a job scheduling system within Akkatecture. It introduces a set of interfaces (IJob, IJobManager, IJobScheduler, IJobRunner) and actors to manage job lifecycles. The JobScheduler is a persistent actor that handles scheduling, cancellation, and execution of jobs, emitting events like Scheduled, Cancelled, and Finished. It uses a tick-based mechanism to trigger jobs at specified times, with support for recurring schedules via the Schedule command. The JobManager acts as a central hub, forwarding job commands to the appropriate scheduler and runner actors, which are wrapped in backoff supervisors for resilience. The system is configurable via JobSchedulerSettings, allowing customization of journal and snapshot plugin IDs and the tick interval.

src/Akkatecture/Jobs · high confidence

This change introduces the \AggregateSagaManager\ and its associated settings (\AggregateSagaManagerSettings\, \AggregateSagaSettings\) to the \Akkatecture.Sagas.AggregateSaga\ namespace. The manager acts as an Akka actor that automatically subscribes to saga event types (both sync and async) when the \auto-subscribe\ configuration is enabled, and automatically spawns saga instances upon receiving domain events when \auto-spawn-on-receive\ is active. This simplifies saga lifecycle management by removing the need for manual event stream subscription and actor creation logic in user code.

src/Akkatecture/Sagas/AggregateSaga · high confidence

The Akkatecture library now includes a new \Entity\<TIdentity\>\ abstract base class and \IEntity\/\IEntity\<TIdentity\>\ interfaces in the \Akkatecture.Entities\ namespace. The \Entity\ class provides a generic implementation for entities with a typed identity, inheriting from \ValueObject\ to ensure value-based equality semantics, while the interfaces define the contract for identity retrieval and access. This establishes the foundational structure for defining domain entities within the framework.

src/Akkatecture/Entities · high confidence

The \src/Akkatecture/Aggregates/ExecutionResults\ directory now contains the core types for handling aggregate execution outcomes. This includes the \IExecutionResult\ interface, the abstract \ExecutionResult\ base class with static factory methods for success and failure states, and concrete implementations \SuccessExecutionResult\ and \FailedExecutionResult\ (which carries an error collection). This provides a structured way to represent whether an aggregate command succeeded or failed, and if it failed, what specific errors occurred.

src/Akkatecture/Aggregates/ExecutionResults · high confidence

The \Akkatecture.Subscribers\ namespace now provides a new \DomainEventSubscriber\ base class that enables automatic discovery and registration of event handlers. By implementing the \ISubscribeTo\ or \ISubscribeToAsync\ interfaces, subscribers can have their \Handle\ and \HandleAsync\ methods automatically registered with the Akka EventStream and actor receive loops, controlled by the \AutoSubscribe\ and \AutoReceive\ settings in the \akkatecture.domain-event-subscriber\ configuration section.

src/Akkatecture/Subscribers · high confidence

The core library now includes a new system for managing versioned types, allowing users to define and retrieve typed definitions by name and version. This change introduces the \IVersionedType\ marker interface, a \VersionedTypeAttribute\ for marking types with a name and version, and a \VersionedTypeDefinition\ base class. It also adds the \VersionedTypeDefinitionService\, which provides methods to load, store, and query these definitions, enabling more robust handling of evolving type schemas within the application.

src/Akkatecture/Core/VersionedTypes · high confidence

A new ActorRefProvider class and its generic variant have been added to the Akka integration layer, providing a wrapper around Akka's IActorRef. This change introduces extension methods (Tell and Ask) that allow users to send messages and request responses through this provider abstraction, decoupling direct Akka actor references from the application logic.

src/Akkatecture/Akka · high confidence

The \src/Akkatecture.TestFixture/Aggregates\ location now includes the \AggregateFixture\ class and its supporting interfaces (\IFixtureArranger\, \IFixtureExecutor\, \IFixtureAsserter\). This adds a new capability to the test fixture: the \ThenExpectReply\ method, which allows tests to assert on the specific reply message returned by an aggregate when a command is processed, in addition to the existing ability to assert on domain events.

src/Akkatecture.TestFixture/Aggregates · high confidence

The library now ships with a set of ready-to-use specification classes in the \Akkatecture.Specifications.Provided\ namespace, allowing users to validate aggregates without writing custom logic from scratch. These include \AggregateIsNewSpecification\ to check if an aggregate is new, \ExpressionSpecification\ for validating against lambda predicates, and logical combinators (\AndSpecification\, \OrSpecification\, \NotSpecification\, \AllSpecifications\, \AtLeastSpecification\) to compose complex validation rules. This adds new capabilities to the framework's validation API rather than changing existing behavior.

src/Akkatecture/Specifications/Provided · high confidence

The Akkatecture cluster example has been restructured into three distinct console applications: a Client, a Seed node, and a Worker. The Worker application now hosts the clustered aggregates (specifically UserAccount) and is configured to run on port 7001, while the Seed node initializes the cluster on port 7000. The Client application connects to the cluster via a singleton proxy on port 7100, allowing users to send commands to create random user accounts. Each component includes its own configuration file (client.conf, seed.conf, worker.conf) and entry point (Program.cs) to demonstrate the full lifecycle of a clustered Akkatecture deployment.

examples/cluster/Akkatecture.Examples.Worker · high confidence

This change introduces the core factory classes for running Akkatecture components in a clustered environment. ClusterFactory enables starting clustered aggregate managers and aggregate sagas using Akka Cluster Sharding, handling entity routing via new MessageExtractor implementations that identify entities by command aggregate IDs or saga locator events. SingletonFactory provides similar support for domain event subscribers using Akka Cluster Singleton, ensuring only one instance runs per cluster role. These components allow users to deploy their aggregates, sagas, and subscribers across multiple nodes with automatic distribution and failover.

src/Akkatecture.Clustering/Core · high confidence

This change introduces the core infrastructure for integrating Akkatecture with .NET's built-in dependency injection system. It adds the \IAkkatectureBuilder\ interface and its \AkkatectureBuilder\ implementation, which expose the underlying \IServiceCollection\ and \ActorSystem\. Additionally, it provides extension methods on \IServiceCollection\ to register the actor system and register typed actor references (\ActorRefProvider\) into the service container, enabling users to inject Akka actors into their application services.

src/Akkatecture/Configuration/DependancyInjection · high confidence

A new \Consumer\ class has been added to the \Query\ namespace to facilitate reading event streams for aggregates. It provides factory methods to initialize the consumer with an existing \ActorSystem\ or configuration, and a \Using\<TJournal\>\ method to bind a specific Akka Persistence query journal. The generic \Consumer\<TJournal\>\ implementation exposes \EventsFromAggregate\ and \CurrentEventsFromAggregate\ methods, which query events by aggregate tag and map them into \EventEnvelope\ objects using a \DomainEventReadAdapter\.

src/Akkatecture/Query · high confidence

This change introduces a suite of new extension methods in the Akkatecture.Extensions namespace to improve developer experience and internal type handling. For users, this means easier composition of query specifications via LINQ-style extension methods (All, AtLeast, And, Or, Not) on IEnumerable\<ISpecification\<T\>\> and individual specifications. It also adds convenience methods for actor contexts to retrieve child actors by identity, utilities for converting identities and source IDs to bytes or checking for null/empty states, and a DateTimeOffset helper for Unix time conversion. Internally, the TypeExtensions class now provides cached, pretty-printed type names for logging and reflection-based discovery of Apply and Hydrate methods for aggregates, as well as name resolution for aggregates, sagas, and jobs.

src/Akkatecture/Extensions · high confidence

The clustering library now includes two new dispatcher components in the \Dispatchers\ namespace to handle distributed message routing. \ShardedAggregateSagaDispatcher\ enables sharded saga management by creating a cluster proxy to an aggregate saga manager and subscribing to relevant saga event types, while \SingletonDomainEventSubscriberDispatcher\ routes domain events to a single subscriber proxy instance. These additions allow applications to leverage Akka clustering for scalable saga coordination and centralized event subscription.

src/Akkatecture.Clustering/Dispatchers · high confidence

This change introduces the core types and interfaces for the new snapshotting capability in the Akkatecture framework. It adds the \CommittedSnapshot\ class to represent persisted state, along with interfaces like \IAggregateSnapshot\, \ISnapshotStrategy\, and \ISnapshotHydrater\ to define how snapshots are created and applied. The update also includes \SnapshotMetadata\ and \SnapshotMetadataKeys\ for tracking versioning and identity, and the \SnapshotDefinitionService\ to manage snapshot type definitions, enabling users to implement snapshot-based performance optimizations for their aggregates.

src/Akkatecture/Aggregates/Snapshot · high confidence

This change introduces the core components for managing saga timeouts within the Akkatecture framework. It adds interfaces for sagas to handle timeout events (both synchronous and asynchronous), defines the base interface for saga timeout jobs, and implements the necessary job runner, scheduler, and manager classes to execute these timeouts via the Akka actor system.

src/Akkatecture/Sagas/SagaTimeouts · high confidence

The entire \src/Akkatecture.Core\ library has been removed, deleting all source files and build artifacts. This eliminates the framework's foundational capabilities, including the Actor-based Aggregate Root and Aggregate Manager implementations, Saga orchestration interfaces, Command and Event handling abstractions, and core value objects like Identity and SourceId. Users of this library will lose access to the core domain modeling and persistence infrastructure provided by Akkatecture.

src/Akkatecture.Core · high confidence

The Program.cs file, which previously served as the entry point for the UserAccount example application, has been removed. This eliminates the hardcoded ActorSystem initialization and the direct command execution logic that demonstrated the aggregate manager in action.

examples/Akkatecture.Examples.UserAccount.Application · high confidence

The example project has removed the initial implementation files for the UserAccount aggregate, including the command definitions (CreateUserAccountCommand, UserAccountChangeNameCommand), event classes (UserAccountCreatedEvent, UserAccountNameChangedEvent), the aggregate root and manager, and the associated state and ID types. This cleanup eliminates the early-stage scaffolding that was previously used to demonstrate basic event sourcing mechanics within the UserAccountModel.

examples/Akkatecture.Examples.UserAccount · high confidence

Command handlers in the \Akkatecture.Commands\ namespace have been updated to accept an \IActorContext\ parameter, allowing implementations to access actor-specific information like logging directly during command handling. Additionally, the \SingleValueObject\ base class now validates that enum values are actually defined in the target enum, throwing an \ArgumentException\ for invalid inputs, and the \Command\ class no longer exposes the commented-out \PublishAsync\ method.

src/Akkatecture/Commands · high confidence

The Akkatecture.Core library has been restructured with several key changes: new interfaces IIdentity, IMetadataContainer, and ISourceId have been introduced to standardize identity and metadata handling; the Identity class initialization logic has been moved from a static constructor to static field initializers for cleaner code; a new deterministic GUID namespace for Snapshots has been added to GuidFactories; and the ReflectionHelper utility has been refactored to support more flexible method compilation while removing obsolete code-base resolution methods. These changes improve the core API surface and internal code quality without altering external behavior.

src/Akkatecture/Core · high confidence

The clustering library now includes a new ClusterParentProxy actor that manages a child actor and automatically sends an UnsubscribeFromAll signal to it upon initialization if configured. This new message, which replaces the previous ISourceId interface in the core module, allows for explicit unsubscription from all subscriptions, changing how actors handle cleanup within the cluster context.

src/Akkatecture.Clustering, src/Akkatecture/Messages · high confidence

Akkatecture now provides a built-in configuration layer that automatically binds the \AggregateEventTagger\ to the in-memory persistence journal, ensuring all committed events are tagged for efficient querying. The default settings also enable auto-subscription for aggregate saga managers and domain event subscribers, as well as auto-receive capabilities for sagas, reducing the manual setup required to wire up these components. Additionally, default behaviors for aggregate roots, such as using default event/snapshot recovery handlers and setting a 5-minute receive timeout for inactive actors, are now applied out of the box.

src/Akkatecture/Configuration · high confidence

The project has replaced its previous build scripts with a new FAKE (F\# Make) build system. This change introduces a set of Azure Pipelines YAML definitions for development, master, release, and static CI workflows, along with shell and command-line helpers to bootstrap the FAKE tooling. Users can now build the solution locally using the provided \fake.sh\ or \fake.cmd\ scripts, which handle dependency restoration, SonarQube analysis, testing, and package publishing to NuGet feeds.

build · high confidence

The repository has been restructured to support a more modular architecture, introducing new projects for clustering (Akkatecture.Clustering), testing (Akkatecture.TestFixture, Akkatecture.TestHelpers), and job scheduling examples. A new Directory.Build.props file centralizes all dependency versions, including Akka.NET 1.4.17, and enforces the .NET Core 2.2 target framework. The solution also migrates from Visual Studio 15 to 16, updates the license to MIT, and adds standard governance files like CHANGELOG.md, CODE\_OF\_CONDUCT.md, and THIRD-PARTY-NOTICES.txt.

(repo-wide) · high confidence

The aggregate subsystem has been restructured to improve event metadata and command dispatching. The \Metadata\ class now tracks \CorrelationId\ and \CausationId\, and \AggregateSequenceNumber\ has been widened from \int\ to \long\ to support larger event streams. A new \AggregateManager\ actor has been introduced to handle command dispatch and dead-letter re-dispatch, controlled by new \AggregateManagerSettings\ (e.g., \HandleDeadLetters\, \AutoDispatchOnReceive\). Additionally, core interfaces like \IEventApplier\ have been renamed to \IMessageApplier\ and moved to the \Akkatecture.Aggregates\ namespace to better reflect their role in applying both events and snapshots.

src/Akkatecture/Aggregates · high confidence

Added Akka configuration helpers for testing; Added integration tests for saga timeouts and async sagas; Added multi-node cluster tests for aggregates and sagas; Added multi-node test runner infrastructure; Added serialization tests for core event and command types; Added test command fixtures for aggregate testing; Added test fixtures for aggregate event upcasters; Added test fixtures for aggregate validation; Added test helper for state signal events; Added test helper specifications for validation logic; Added test helper utilities for categorization and serialization; Added test helpers for aggregate event subscribers; Added test helpers for job execution and scheduling; Added test helpers for synchronous and asynchronous saga workflows; Added test scaffolding for the test aggregate; Added unit tests for SingleValueObject serialization and equality; Added unit tests for Specification logic and test helpers; Added unit tests for TypeExtension methods; Added unit tests for aggregate lifecycle, fixtures, and event contracts; Added unit tests for clustering sharding message extraction; Added unit tests for command instantiation and validation; Added unit tests for core infrastructure components; Added unit tests for mapping components; Added unit tests for scheduled job execution; Added unit tests for subscriber event handling; Removed empty test helper project.

The project has replaced its previous dependency management approach with Paket, introducing a centralized \paket.dependencies\ file and a corresponding \paket.lock\ for reproducible builds. This change also standardizes the target frameworks across all projects (including the core library, clustering module, test fixtures, and examples) to use version variables (\$(NetStandardVersion)\ and \$(NetCoreAppVersion)\) rather than hardcoded versions, aligning the codebase with .NET Core LTS releases. Additionally, several example projects have been reorganized or removed, and the main library now explicitly references specific versions of Akka.NET, Newtonsoft.Json, and Microsoft.Extensions.DependencyInjection.Abstractions.

(dependencies) · high confidence

Deleted generated dependency and runtime configuration files (deps.json, runtimeconfig.json, and runtimeconfig.dev.json) from the test project's bin directory. These files are build artifacts and should not be tracked in version control.

test/Akkatecture.Tests/bin · high confidence

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

• CAI 52 → 52 (-0.1)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 69 → 62 (-6.8)
• Architecture 97 → 97 (+0.0)
• Maturity 57 → 57 (+0.0)
• Readiness 43 → 43 (-0.1)
• Security 87 → 89 (+1.1)
• Domain Modelling 60 → 64 (+4.5)
• Event-Driven 83 → 83 (+0.0)
• Performance 54 → 54 (+0.0)

• Bounded contexts not declared
• Build did not complete in the analyzer
• Coverage not measured
• LLM evaluation failed
• No exposed public API
• Split Akkatecture
• Test reliability not measured — no test run produced results
• The class name 'ComittedEventTests' contains a typo ('Comitted' instead of 'Committed'). This is a clear spelling inconsistency compared to the correct usage of 'Committed' elsewhere in the codebase (e.g., CommittedEvent, ICommittedEvent).
• The namespace Akkatecture.Configuration.DependancyInjection uses the misspelling 'Dependancy' instead of 'Dependency'. This is a spelling inconsistency compared to standard English and likely other correct usages in the codebase.
• The term 'Upcaster' is used in the class name for the implementation, but 'Upcaster' is also used in the test class name. However, looking at the namespace Akkatecture.TestHelpers.Aggregates.Events.Upcasters vs Akkatecture.Tests.UnitTests.Mapping, the concept of 'Upcasting' is present. A more direct inconsistency is found in the spelling of 'Committed' vs 'Comitted'.
• dormant codebase — no living knowledge left to concentrate

• Assertions commented out: TestDistinctCommand_AfterTwoHandles_CommandFails (test/Akkatecture.Tests/UnitTests/Aggregates/AggregateTests.cs)
• BareSuppressMessage (test/Akkatecture.Tests.MultiNode/AggregateClusterTests.cs)
• BareSuppressMessage (test/Akkatecture.Tests.MultiNode/AggregateSagaClusterTests.cs)
• CommentedOutCode (test/Akkatecture.Tests/UnitTests/Aggregates/AggregateTests.cs)
• CommentedOutCode (test/Akkatecture.Tests/UnitTests/Jobs/ScheduledJobsTests.cs)
• Dead code: GetAggregateEventApplyMethods (src/Akkatecture/Extensions/TypeExtensions.cs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Dormant codebase
• Duplicated block (11 lines × 2) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (11 lines × 8) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (12 lines × 2) (src/Akkatecture/Extensions/TypeExtensions.cs)
• Duplicated block (12 lines × 2) (src/Akkatecture/Query/Consumer.cs)
• Duplicated block (13–14 lines × 3) (src/Akkatecture/Sagas/AggregateSaga/AggregateSaga.cs)
• Duplicated block (13–14 lines × 5) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (13–15 lines × 4) (src/Akkatecture.Clustering/Extentions/TypeExtensions.cs)
• Duplicated block (15 lines × 2) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (15–18 lines × 5) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (15–19 lines × 3) (src/Akkatecture/Jobs/JobRunner.cs)
• Duplicated block (17 lines × 2) (src/Akkatecture/Extensions/TypeExtensions.cs)
• …and 40 more

• Unchanged — 5 HTTP endpoints

• Unchanged — 0 containers · 2 contexts · 1 edges

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

ThembisileNGQ/Akkatecture 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.