loresoft/Arbiter

Arbiter is a .NET library ecosystem that provides a structured Command Query (CQRS) framework with built-in support for Entity Framework Core and MongoDB, including automatic CRUD handlers, caching, and multi-tenancy. It extends this data layer with distributed messaging capabilities via Azure Service Bus and Web PubSub for cache invalidation, alongside a dedicated communication module for sending emails and SMS through various providers. The system also offers Blazor UI components and client-side state management utilities to streamline full-stack application development.

79 changes.

The project established its core architecture by introducing the Arbiter.Mediation and Arbiter.CommandQuery libraries, implementing a comprehensive CQRS pattern with support for Entity Framework Core and MongoDB. Concurrently, the Arbiter.Communication module was developed to provide email and SMS delivery services with template rendering. The period also included the creation of the Arbiter.Dispatcher for client-server communication and the development of sample applications to demonstrate these capabilities.

17 changes.

This period focused on expanding the Arbiter ecosystem with new Azure messaging integrations, including Service Bus and Web PubSub support for distributed cache expiration and health monitoring. It also introduced a new health check module, OpenTelemetry instrumentation, and a set of standardized base classes for Blazor pages to streamline UI development.

A new sample application has been added to the samples/MongoDB directory, demonstrating a multi-tenant task tracking service built on MongoDB. This implementation includes the full domain layer with entities for Tasks, Users, Tenants, Priorities, and Statuses, along with corresponding repositories, AutoMapper profiles, and FluentValidation rules. The service is wired up using the Arbiter Command Query framework and exposes REST endpoints for CRUD operations and task processing.

samples/MongoDB · high confidence

The Arbiter.OpenTelemetry.Server package now provides a centralized way to configure OpenTelemetry for server-side applications. It introduces an extension method, AddOpenTelemetry, which sets up logging, metrics, and tracing with sensible defaults. Users can configure application metadata (name, version, environment), set minimum log levels, and define logging filters. The package automatically instruments ASP.NET Core, HTTP clients, runtime, and SQL Client, and adds sources for Arbiter.Mediation, Arbiter.Dispatcher, and messaging transports (ServiceBus, WebPubSub). It also supports filtering specific request path segments from tracing and exports telemetry via OTLP if the OTEL\_EXPORTER\_OTLP\_ENDPOINT environment variable is set.

src/Arbiter.OpenTelemetry.Server · high confidence

This change introduces new implementations for sending emails via SendGrid and SMS messages via Twilio, making them available as pluggable delivery options. The SendGrid service supports configuring API keys, handling recipients (To, Cc, Bcc), attachments, and reply-to addresses, and includes a recipient override feature for testing or staging environments. The Twilio service handles SMS sending with configurable sender numbers and credentials, and now reports the number of SMS segments used in the result. Both services are registered with dependency injection via extension methods (AddSendGridEmailDeliver and AddTwilioSmsDeliver) that accept either configuration delegates or direct credentials.

src/Arbiter.Communication.Twilio · high confidence

Introduced TenantCreateModel, TenantReadModel, and TenantUpdateModel classes in the Tracker.Shared domain layer. These models define the structure for tenant data, including Name and Description fields, with TenantReadModel additionally exposing TaskCount and a list of Tasks, while supporting search and sorting capabilities via the ISupportSearch interface.

samples/EntityFramework/src/Tracker.Shared/Domain/Tenant/Models · high confidence

The sample application now includes Tenant mapping profiles that convert between TenantReadModel, TenantCreateModel, and TenantUpdateModel. These mappings are implemented using the Arbiter.Mapping library, with each profile registered as a singleton and exposing a ConfigureMapping method for custom mapping logic.

samples/EntityFramework/src/Tracker.Shared/Domain/Tenant/Mapping · high confidence

This change introduces the client-side Razor components for the Tracker sample application, providing the core user interface structure. It includes layout components (ApplicationBar, Footer, MainLayout, ProfileMenu) that establish the navigation bar with task and administrative menus, user authentication links, and version display. It also adds specific page components for handling user states and errors (AccessDenied, NotFound, Signin) and a reusable EntitySelect component for data entry, along with an IconSelector for status visualization.

samples/EntityFramework/src/Tracker.Client/Components · high confidence

The Tracker.Client sample application now includes a full set of Razor pages for managing its domain entities. Users can view and edit Tenants, Users, Priorities, and Statuses via dedicated List and Edit views. Task management is supported through List, Edit, and Search pages, with the search functionality allowing real-time filtering by text and the list view supporting filtering by status and priority via URL parameters. Additionally, a Health Check page has been added to display system health status and duration metrics.

samples/EntityFramework/src/Tracker.Client/Pages · high confidence

A new sample client application (Tracker.Client) has been added to demonstrate a WebAssembly-based Blazor app. This includes the main entry point (Program.cs) which configures authentication, authorization, and shared services, along with a routing configuration (Routes.razor) that integrates with the Arbiter component library for modal handling and role-based access control. The sample also provides a shared RouteLinks class to define typed URL paths for entities like Priorities, Statuses, Tenants, Users, and Tasks, facilitating consistent navigation across the application.

samples/EntityFramework/src/Tracker.Client · high confidence

Introduces the Tracker.Web sample application, a Razor Components app featuring Microsoft Identity authentication, OpenTelemetry-based logging and metrics, request logging middleware, and integration with the Arbiter dispatcher and WebPubSub messaging services.

samples/EntityFramework/src/Tracker.Web · high confidence

The Tracker sample application now includes generated mapping profiles and dependency injection registrations for its core domain entities: Priority, Status, Task, Tenant, and User. Each entity has a dedicated mapper class (e.g., \PriorityMapper.cs\) that defines how database entities are transformed into read and update models, with specific logic for computed properties like task counts and related names. Corresponding service registration files (e.g., \PriorityServiceRegistration.cs\) register these mappers and the associated Entity Framework queries and commands with the service collection, enabling the application to handle data access and command execution for these aggregates.

samples/EntityFramework/src/Tracker.Core/Domain · high confidence

The Arbiter.Communication module now includes structured result types for email and SMS operations. EmailResult exposes success status, optional messages, and exception details for email delivery outcomes. SmsResult extends this pattern to include a Segments property, allowing users to see how many message segments an SMS was split into, along with success status, messages, and exception information.

Arbiter.Communication · high confidence

The sample application now includes a health check registration module that configures basic liveness and database connectivity monitoring. It registers a default liveness check to verify application responsiveness and adds an Entity Framework database health check for the TrackerContext, allowing users to monitor the health status of the sample app's core dependencies.

samples/EntityFramework/src/Tracker.Core/Health · high confidence

This change introduces a new sample application located in \samples/EntityFramework/src/Tracker.Shared/Extensions\, providing a set of helper utilities for the sample project. It includes \ClaimsPrincipalExtensions\ to simplify extracting user identity details (such as email, name, and object ID) from security claims, \JsonSerializerOptionsExtensions\ to configure JSON serialization with domain-specific converters (including polymorphic request handling), and \StringExtensions\ for common string operations like truncation, null/whitespace checking, and path combining.

samples/EntityFramework/src/Tracker.Shared/Extensions · high confidence

This change introduces the core data access components for the Tracker sample, including the \TrackerContext\ DbContext, entity models for Task, User, Tenant, Priority, and Status, and their corresponding Entity Framework Core mapping configurations. It also adds \DataServiceRegistration\ to configure the \TrackerContext\ with Azure SQL, enabling connection pooling, retry logic, and specific query splitting behaviors for the sample application.

samples/EntityFramework/src/Tracker.Core/Data · high confidence

Added JavaScript implementations of AES-256-CBC encryption for both Node.js (using the native \crypto\ module) and browsers (using the Web Crypto API) in the \samples/JavaScript\ directory. These samples provide \encrypt\, \decrypt\, and \generatePassword\ functions that are compatible with the project's C\# \AesEncryption\ class, allowing data encrypted in C\# to be decrypted in JavaScript and vice versa. The implementation uses PBKDF2 for key derivation and includes a test suite to verify functionality and cross-platform compatibility.

samples/JavaScript · high confidence

The Entity Framework sample now includes a complete SQL Server database project (Tracker.Database) defining the core tables for the application: Priority, Status, Task, Tenant, and User. This addition provides the underlying data structure, including foreign key relationships and indexes, along with post-deployment scripts to seed initial data (such as default priorities, statuses, and sample users like William Adama). A build fix for .NET Framework projects is also included in the project file to ensure compatibility.

samples/EntityFramework · high confidence

The sample application now includes an AuthenticationEndpoint that exposes routes for initiating OpenID Connect sign-in and sign-out operations. These endpoints are registered under a configurable route prefix and allow anonymous access, enabling users to authenticate via OpenID Connect and log out using both OpenID Connect and cookie-based schemes.

samples/EntityFramework/src/Tracker.Web/Endpoints · high confidence

The Tracker.Shared sample application now includes the domain definitions for Priority and Status. This adds constants for priority levels (High, Normal, Low) and status values (NotStarted, InProgress, Completed, Blocked, Deferred), along with corresponding Create, Read, and Update models. These models support search and sorting capabilities and are paired with FluentValidation rules and Arbiter-based mappers to handle data transformation between read and write models.

samples/EntityFramework/src/Tracker.Shared/Domain/Priority, samples/EntityFramework/src/Tracker.Shared/Domain/Status · high confidence

This change introduces the foundational domain layer for the Tracker sample application by adding shared models, mapping profiles, and validation rules for both Task and User entities. For Tasks, it defines read, create, and update models (including fields like Title, Description, StartDate, and StatusId), along with FluentValidation rules ensuring the Title is not empty and under 255 characters. Similarly, it adds User models (with DisplayName and EmailAddress) and validators enforcing non-empty, max-length constraints. The entry also includes Arbiter.Mapping-based mapper profiles to handle conversions between these models (e.g., ReadModel to CreateModel) and registers them as singletons, establishing the data transformation and validation infrastructure for these core entities.

samples/EntityFramework/src/Tracker.Shared/Domain/Task · high confidence

The \src/Arbiter.Mapping.Generators/Infrastructure\ directory now includes new support files to aid the mapping generator: \CollectionBuilderAttribute\ and \IsExternalInit\ shim classes for compiler compatibility, an \EquatableArray\<T\>\ struct for value-based equality in incremental models, and an \IndentedStringBuilder\ class to simplify generating indented source code.

src/Arbiter.Mapping.Generators/Infrastructure · high confidence

The Tracker.Core sample now includes a ServiceRegistration class that configures hybrid caching and optional Web PubSub integration for distributed cache expiration, alongside a generation.yml file that defines the code generation settings for the sample application, including database provider, entity models, and mapping templates.

samples/EntityFramework/src/Tracker.Core · high confidence

The Arbiter.CommandQuery module now includes a custom MessagePack formatter that preserves the original runtime type of object properties during serialization, rather than flattening them into generic arrays. This change ensures that deserialized data retains its specific type information, improving data fidelity for consumers relying on precise type distinctions in command and query responses.

src/Arbiter.CommandQuery/Formatters · high confidence

The library now includes services to extract user identity and tenant information from security claims. A new \PrincipalReader\ service provides strongly-typed methods to retrieve email, name, display name, object ID, user ID, and tenant ID from a \ClaimsPrincipal\, handling fallbacks across standard and custom claim names. A \TenantResolver\ service wraps this reader to convert the tenant identifier into a specified type, and a \ClaimNames\ class centralizes the constants for these claim keys.

src/Arbiter.CommandQuery/Services · high confidence

The Arbiter Dispatcher endpoint now accepts and returns data in MessagePack format in addition to the existing JSON support. Clients can choose the serialization format by setting the Content-Type header to application/x-msgpack, which triggers binary MessagePack serialization for more compact and faster payloads. The server also returns a response type header to help clients correctly deserialize the MessagePack response. This change is implemented via new client-side DI extensions (AddMessagePackDispatcher/AddJsonDispatcher), a server-side endpoint that routes based on content type, and a custom MessagePackResult type for ASP.NET Core minimal APIs.

src/Arbiter.Dispatcher.Server · high confidence

The new Arbiter.Messaging.WebPubSub package enables distributed cache invalidation across application instances using Azure Web PubSub. When a command modifies cached data, the system now publishes an expiration message to a configured hub and group, allowing other instances to remove matching keys and tags from their local HybridCache. This behavior is opt-in via extension methods like AddWebPubSubCacheExpire, which register the necessary publisher and subscriber components. Additionally, the package includes a health check extension to verify connectivity to the Web PubSub service, ensuring operational visibility.

src/Arbiter.Messaging.WebPubSub · high confidence

Applications using HybridCache can now keep local caches consistent across multiple instances by publishing expiration messages to an Azure Service Bus topic. This change adds a new behavior that automatically expires local cache entries and publishes a message when a command modifies data, along with a processor that receives these messages and removes the corresponding entries from other instances' caches. Users enable this by registering the publisher and subscriber extensions, configuring the Service Bus topic and subscription, and marking commands with the ICacheExpire interface.

src/Arbiter.Messaging.ServiceBus/Cache · high confidence

The Arbiter Command Query library now includes an Entity Framework Core integration package that registers command and query handlers via service extensions, enabling automatic CRUD operations and paged queries for entities. This update introduces a custom SequentialGuidGenerator for SQL Server, which produces sequential GUID values to optimize index performance, and provides extension methods to configure this behavior on entity properties.

src/Arbiter.CommandQuery.EntityFramework · high confidence

This change introduces the foundational Blazor Server components for the Tracker sample application, including the main App layout, error handling page, and global imports. The App.razor component sets up the HTML structure with Bootstrap 5.3.5 styling, integrates the LoreSoft.Blazor.Controls library, and configures interactive rendering modes based on HTTP context. The Error.razor page provides a standard error view with request ID tracking, while \_Imports.razor consolidates necessary namespaces for the Tracker.Client and Tracker.Web component hierarchies.

samples/EntityFramework/src/Tracker.Web/Components · high confidence

The repository has been initialized with the core project structure for the Arbiter library, including solution files (Arbiter.slnx), project definitions for core libraries (Mediation, CommandQuery, Mapping, Services, Communication), data providers (EntityFramework, MongoDB), web integrations (Endpoints, Mvc), and Blazor components. The diff also adds configuration files such as .editorconfig, .gitattributes, global.json, and an Aspire configuration, along with comprehensive documentation in README.md and sample applications for Entity Framework and MongoDB.

(repo-wide) · high confidence

This change introduces the foundational structure for the Tracker sample application. It adds FluentValidation rules for tenant creation and updates, ensuring name and description fields are validated. Configuration support is provided through options classes for authentication routing and environment settings, which are registered with the service collection. Additionally, the web layer includes initial CSS styles for layout and form validation feedback, along with JavaScript utilities to handle file downloads via stream references and URLs.

samples/EntityFramework/src/Tracker.Shared/Domain/Tenant/Validation, samples/EntityFramework/src/Tracker.Shared/Options, samples/EntityFramework/src/Tracker.Web/wwwroot · high confidence

The new Arbiter.CommandQuery library provides a command/query pipeline built on the Mediator pattern, registering core services like the mediator, principal reader, mapper, and tenant resolver via \AddCommandQuery\. It includes automatic validation through a pipeline behavior (\AddCommandValidation\) and flexible hybrid caching for queries and command-based invalidation (\AddEntityHybridCache\). The library supports both JSON and MessagePack serialization, with MessagePack configured via \AddMessagePackOptions\ using LZ4 compression and a composite resolver. Additionally, it offers conditional pipeline behaviors for entity queries and creates based on interfaces like \IHaveTenant\ and \ITrackDeleted\, and introduces a \DomainException\ with HTTP status code support for domain-level error handling.

src/Arbiter.CommandQuery · high confidence

The \src/Arbiter.CommandQuery/Models\ directory now contains a comprehensive set of data models for the Command Query library, including \CompleteModel\ for operation results, entity lifecycle models (\EntityCreateModel\, \EntityReadModel\, \EntityUpdateModel\) with concurrency tracking, and \ProblemDetails\ for standardized error responses. All models are annotated with \\[MessagePackObject(true)\]\ to enable MessagePack serialization alongside standard JSON, and include specific fields for health reporting (\HealthEntryModel\, \HealthReportModel\) and validation (\ValidationResult\).

src/Arbiter.CommandQuery/Models · high confidence

The new Arbiter.Health project provides a health check system integrated with the Arbiter mediation layer. It adds a \HealthCheckHandler\ that executes registered health checks and returns a structured report, and a \ConfigurationQueryHandler\ that flattens application configuration into key-value entries with provider metadata. The library exposes \AddHealthServices\ for DI registration and extension methods (\AddUrlCheck\) to easily register URL-based health probes using either static URLs or factories, supporting configurable HTTP methods, timeouts, and failure statuses.

src/Arbiter.Health · high confidence

The Arbiter.Mediation library is now available, providing a mediator pattern for decoupling request/response and notification handling. It includes the IMediator interface with generic and non-generic Send methods, a Publish method for notifications, and support for pipeline behaviors via IPipelineBehavior. The implementation (Mediator) integrates with .NET dependency injection through MediatorServiceExtensions.AddMediator and includes built-in OpenTelemetry instrumentation (ActivitySource and Meter) for tracing and metrics on send and publish operations, with specific attributes for Native AOT and trimming safety on non-generic overloads.

src/Arbiter.Mediation · high confidence

The Arbiter.CommandQuery library now provides a set of cacheable query classes for retrieving entities: EntityIdentifierQuery for single-entity lookups by primary key, EntityIdentifiersQuery for batch retrieval by a list of keys, EntityKeyQuery for lookups by a globally unique alternate key (Guid), and EntityPagedQuery for filtered, sorted, and paginated results. All queries support optional named filter pipelines (via the FilterName property) to apply context-specific modifications such as security policies or data transformations, and they integrate with the caching infrastructure to improve performance for frequently accessed data. Additionally, an EntityChangeNotification class has been added to signal entity modifications.

Arbiter.CommandQuery · high confidence

The Queries area now provides a complete set of types for defining and executing entity queries, including EntityQuery (filtering, sorting, pagination), EntityFilter (with support for keyed fields and nested logical groups), and EntitySort (with flexible string parsing). These models are fully serializable to JSON via custom converters (ClaimsPrincipalConverter, EntityFilterConverter, PolymorphicConverter) and MessagePack, and are backed by enums for filter operators and logic. A builder utility (EntityFilterBuilder) and LINQ expression generator (LinqExpressionBuilder) are included to help construct and translate these queries.

src/Arbiter.CommandQuery/Queries · high confidence

The client library now exposes an IDispatcher interface that unifies local and remote message dispatching. For remote scenarios, JsonDispatcher and MessagePackDispatcher allow requests to be sent over HTTP using either JSON or MessagePack serialization, with optional hybrid caching for cacheable requests. A ServerDispatcher is also provided for Blazor Interactive Server rendering, delegating directly to IMediator.

src/Arbiter.Dispatcher.Client/Client · high confidence

The Arbiter.Communication library now includes a new SMS module that enables sending text messages via a pluggable delivery service (with a built-in in-memory implementation for testing). Users can send messages using named templates or direct template objects, binding data models to the message body and specifying a sender number (falling back to a configured default). The module also provides a utility for calculating SMS segments based on GSM-7 and UCS-2 encoding rules, ensuring accurate message length estimation for single and concatenated SMS messages.

src/Arbiter.Communication/Sms · high confidence

The Arbiter.Mapping.Generators package now includes a Roslyn analyzer (MapperAnalyzer) that validates mapper classes annotated with \[GenerateMapper\] at compile time. It enforces that mapper classes are partial and inherit from MapperProfile\<TSource, TDestination\>, ensures the ConfigureMapping method only contains recognized mapping calls, flags auto-matched properties with incompatible source and destination types, detects duplicate destination property mappings, and validates the expected mapping call pattern. These checks help catch configuration errors early before the source generator runs.

src/Arbiter.Mapping.Generators · high confidence

The library now provides a set of generic Entity Framework Core handlers for standard CRUD operations (Create, Read, Update, Patch, Delete) and paged queries. These handlers automatically apply audit metadata (created/updated timestamps and users) and support soft deletes for entities implementing ITrackDeleted. A key behavioral addition is the integration of an optional IQueryPipeline, allowing users to apply global modifiers such as multi-tenant filtering or authorization checks to all queries executed by these handlers.

src/Arbiter.CommandQuery.EntityFramework/Handlers · high confidence

The Arbiter.Messaging.WebPubSub package now includes a WebPubSubHubContext record that encapsulates the Azure Web PubSub service client, configuration options, hub name, and group mappings. This component provides a GetGroupName method to resolve formatted group names, serving as the foundational context object for interacting with Azure Web PubSub hubs within the messaging layer.

Arbiter.Messaging.WebPubSub · high confidence

The library now provides a set of reusable pipeline behaviors and base classes for the mediator pattern. Users can automatically enforce multi-tenancy via \TenantAuthenticateCommandBehavior\ and \TenantDefaultCommandBehavior\, which resolve and validate tenant IDs against request principals. Soft-delete filtering is handled by \DeletedPagedQueryBehavior\, which appends \IsDeleted\ filters to paged queries. Caching is managed through \HybridCacheQueryBehavior\ for read-through caching and \HybridCacheExpireBehavior\ for cache invalidation on commands. Entity change notifications are automatically published via \EntityChangeNotificationBehavior\ after create, update, or delete operations. Input validation is supported by \ValidateCommandBehavior\ and \ValidateEntityModelCommandBehavior\. All behaviors and handlers inherit from \PipelineBehaviorBase\ and \RequestHandlerBase\, which provide structured logging and distributed tracing via \ActivitySource\.

src/Arbiter.CommandQuery/Behaviors · high confidence

The Tracker.Shared.Domain project now includes the core domain models (EntityCreateModel, EntityReadModel, EntityUpdateModel) and a generated DomainJsonContext for System.Text.Json source generation. This context explicitly registers serialization support for the sample's entity types (Priority, Status, Task, Tenant, User) along with their associated commands and queries, enabling efficient JSON handling for the sample application.

samples/EntityFramework/src/Tracker.Shared/Domain · high confidence

The Arbiter.Communication library now includes a new template subsystem that allows templates to be resolved from various sources (such as embedded resources) and rendered against data models. This change adds the ITemplateResolver and ITemplateService interfaces, along with a default TemplateResourceResolver that loads YAML templates from assembly resources using YamlDotNet, and a TemplateService that uses the Fluid library to parse and render text templates with model binding and caching.

src/Arbiter.Communication/Template · high confidence

The \Arbiter.CommandQuery.Mvc\ package now provides a set of ASP.NET Core base classes and middleware to simplify building CQRS-based APIs. \MediatorControllerBase\ serves as the foundation, injecting the \IMediator\ for command and query dispatch. \EntityQueryControllerBase\ adds standard read operations (Get, Page) with filtering, sorting, and pagination support. \EntityCommandControllerBase\ extends this with create, update, delete, and JSON patch operations. \EntityExportCommandControllerBase\ and \EntityExportQueryControllerBase\ further extend these to support CSV exports of entity lists. Additionally, \BaseAddressResolver\ helps resolve service base addresses across different hosting environments (Blazor WebAssembly, HTTP Context, Configuration), and \JsonExceptionMiddleware\ provides standardized JSON error responses with trace IDs and development-mode details.

src/Arbiter.CommandQuery.Mvc · high confidence

A new Arbiter.Communication project has been added to support email and SMS messaging capabilities. This includes dependency injection extensions for registering template services (using Fluid), email services (with SMTP support), and SMS services. The library provides configuration options for email and SMS providers, template resolution, and delivery service registration, enabling developers to integrate communication features into their applications.

src/Arbiter.Communication · high confidence

This change introduces new delivery service implementations for sending emails and SMS messages via Azure Communication Services and Microsoft Graph. The \src/Arbiter.Communication.Azure\ package adds \AzureEmailDeliveryService\ and \AzureSmsDeliveryService\, enabling users to route communications through Azure's infrastructure with support for recipient overrides and SMS segment calculation. Additionally, the \src/Arbiter.Communication.Graph\ package provides \GraphEmailDeliverService\ for sending emails via Microsoft Graph, including dependency injection extensions to wire up the required clients and credentials. These additions expand the platform's communication capabilities by offering specific Azure-based backends for both email and SMS channels.

src/Arbiter.Communication.Azure · high confidence

This release introduces two new libraries to the Arbiter ecosystem. The \Arbiter.Functions\ package provides a client for managing Azure Functions via the host admin API, including health checks and typed DI registration. The \Arbiter.Messaging.ServiceBus\ package adds comprehensive Azure Service Bus support, featuring a background queue for mediator requests, automatic entity initialization (queues, topics, subscriptions) at startup, and health checks for both queues and subscriptions.

src/Arbiter.Messaging.ServiceBus · high confidence

The \src/Arbiter.CommandQuery/Commands\ area now introduces a set of foundational CQRS command types. \PrincipalCommandBase\ provides a base for commands requiring user context, automatically capturing the \ClaimsPrincipal\, activation timestamp, IP address, and user agent. Entity operations are standardized through \EntityCreateCommand\, \EntityUpdateCommand\ (which supports upsert semantics), \EntityPatchCommand\ (for JSON patch updates), and \EntityDeleteCommand\. These commands implement \ICacheExpire\ to ensure automatic cache invalidation upon mutation. Additionally, \CacheableQueryBase\ is added to support caching with absolute and sliding expiration policies, and diagnostic commands (\ConfigurationQuery\, \HealthCheckCommand\) are included for system introspection.

src/Arbiter.CommandQuery/Commands · high confidence

This change introduces a complete set of new handlers in the MongoDB integration layer to support Create, Read, Update, Delete, and Patch operations for entities. The new files include EntityCreateCommandHandler, EntityDeleteCommandHandler, EntityUpdateCommandHandler, EntityPatchCommandHandler, EntityIdentifierQueryHandler, EntityIdentifiersQueryHandler, EntityKeyQueryHandler, and EntityPagedQueryHandler, all built on a new RepositoryHandlerBase. These handlers enable users to perform standard entity management tasks against MongoDB repositories, including soft-delete support, metadata tracking (created/updated timestamps and users), and paged querying with filtering and sorting.

src/Arbiter.CommandQuery.MongoDB/Handlers · high confidence

The MongoDB integration now provides a new \DomainServiceExtensions\ class that simplifies registering entity commands and queries. Users can now register standard entity queries (by identifier, multiple identifiers, or paged) and commands (create, update, patch, delete) with a single call, which automatically registers the necessary handlers and pipeline behaviors. A new \AddEntityKeyQuery\ method allows retrieving entities by a unique alternate key, in addition to the primary identifier. Additionally, cache tagging is now automatically applied to entities, read models, and create models during registration to improve cache invalidation accuracy.

src/Arbiter.CommandQuery.MongoDB · high confidence

The Tracker.Service sample application has been added, providing a complete ASP.NET Core service that exposes CRUD endpoints for domain entities (Priority, Status, Task, Tenant, User) via the Arbiter framework. The service includes configurable diagnostic routes (configuration and cache clearing), OpenTelemetry integration for distributed tracing, request logging, and security key-based authentication. It also features a Scalar API reference UI and health check endpoints, demonstrating a fully wired-up backend with Entity Framework Core and Redis caching support.

samples/EntityFramework/src/Tracker.Service · high confidence

Added a set of abstract base classes in src/Arbiter.Components/Abstracts to standardize page implementations. PrincipalComponentBase provides access to the current user, claims, and authorization checks. ModelComponentBase supplies shared utilities for model labels, dirty-state tracking, and page titles. DataPageBase, ListPageBase, ResultPageBase, and NestedListPageBase offer structured patterns for displaying data grids, handling paged or full-result loads, and managing parent-child relationships, while EditPageBase provides a foundation for create/edit forms with change tracking and validation support.

src/Arbiter.Components · high confidence

Added three new classes in the \Arbiter.Dispatcher.Client.State\ namespace to handle client-side model state: \ModelStateManager\ provides a base for tracking model changes and notifying subscribers; \ModelStateLoader\ adds asynchronous loading capabilities with caching and busy-state tracking for read-only scenarios; and \ModelStateEditor\ extends the loader to support full CRUD operations, including dirty-state detection via hash comparison, saving, and deleting. These classes enable Blazor components to manage data loading, editing, and change tracking more effectively.

src/Arbiter.Dispatcher.Client/State · high confidence

The \src/Arbiter.CommandQuery.Endpoints\ package now exposes configurable diagnostic routes (\config-debugger\, \health-check\, \claims-check\, \cache-clear\) that are disabled by default for security and can be enabled via \DiagnosticsEndpointOptions\. It also introduces a \ClaimLoggingMiddleware\ that enriches request logs and distributed tracing with user identity claims (username, user ID, and optional additional claims), ensuring stable logging keys for unauthenticated requests. Additionally, base address resolution is now handled by a configurable \BaseAddressResolver\ supporting Blazor \NavigationManager\, HTTP context, and configuration fallbacks.

src/Arbiter.CommandQuery.Endpoints · high confidence

The \src/Arbiter.CommandQuery/Definitions\ area now exposes a comprehensive set of new interfaces that define core capabilities for entities and request handling. These include \IRequestContext\ and \IRequestPrincipal\ for propagating user identity and request metadata (IP, user agent) through the command pipeline, alongside \IPrincipalReader\ and \IPrincipalResolver\ for claim extraction. Entity modeling is enhanced with \IHaveIdentifier\, \IHaveKey\, and \IHaveTenant\ for primary, alternate, and multi-tenancy keys, while \ICacheExpire\ and \ICacheResult\ standardize cache key/tag generation and expiration policies. Audit and lifecycle tracking are supported via \ITrackCreated\, \ITrackUpdated\, \ITrackDeleted\, \ITrackConcurrency\, \ITrackHistory\, and \ITrackDisabled\. Additional definitions include \IValidator\ for validation contracts, \IResponseType\ for response typing, \ISupportSearch\ for search configuration, \ITenantResolver\ for tenant identification, and \IBaseAddressResolver\ for service endpoint resolution.

src/Arbiter.CommandQuery/Definitions · high confidence

The Arbiter.Communication.Email module introduces a new capability for sending emails via SMTP, supporting both direct message construction through a fluent builder and templated sending with model binding. Users can configure SMTP settings (server, port, SSL, credentials) and leverage features like recipient overrides and subject prefixes for testing. The library includes a memory delivery service for simulation and full support for HTML/text bodies, attachments, and custom headers.

src/Arbiter.Communication/Email · high confidence

The library introduces a suite of extension methods in the \Arbiter.CommandQuery.Extensions\ namespace to streamline common development patterns. \ClaimsExtensions\ and \PrincipalReaderExtensions\ provide strongly typed, culture-invariant helpers for reading, writing, and parsing claims on \ClaimsPrincipal\ and \IPrincipalReader\ instances. \QueryExtensions\ adds \Sort\, \Filter\, and \ProjectTo\ capabilities to \IQueryable\<T\>\, enabling dynamic sorting, filtering, and mapping of database queries. \GuidExtensions\ and \ByteArrayExtensions\ support UUIDv7 generation and byte-order conversion between standard .NET and SQL Server formats for optimal index performance. Additionally, \TaskExtensions\ offers a \RunInBackground\ method to observe and log unhandled exceptions from fire-and-forget tasks, while \ExceptionExtensions\ simplifies converting exceptions into \ProblemDetails\ objects.

src/Arbiter.CommandQuery/Extensions · high confidence

The Entity Framework integration now includes a query pipeline system that allows cross-cutting concerns like soft-delete filtering, tenant isolation, and security checks to be applied to queries. This introduces the IQueryModifier interface for defining transformations, the IQueryPipeline interface and QueryPipeline implementation for applying these modifiers in priority order, and extension methods to easily apply the pipeline to IQueryable queries. The system supports both standard modifiers applied to all queries and named pipelines for context-specific modifier sets.

src/Arbiter.CommandQuery.EntityFramework/Pipeline · high confidence

Added new extension methods to the Arbiter.Communication library to simplify common string operations and data integrity checks. The new HashExtensions class provides a ToXXHash3 method that computes efficient XXHash3 hashes using stack allocation for small inputs and ArrayPool for larger ones. The StringExtensions class introduces utilities for truncating text with custom ellipses, checking for null/empty/whitespace states, and safely combining strings with automatic separator handling.

src/Arbiter.Communication/Extensions · high confidence

This change introduces several new capabilities to the Arbiter platform. In \src/Arbiter.Services\, it adds a suite of high-performance encoding utilities (Base32, Base62), a robust AES-256 encryption service, a cache tagging system, and a new continuation token implementation for keyset pagination. It also includes a CSV reader for data ingestion. Additionally, the \src/Arbiter.OpenTelemetry\ project now defines the core data models (logs, traces, spans) and query structures required to support OpenTelemetry integration, enabling users to query and view telemetry data.

src/Arbiter.Services · high confidence

The sample application now includes a service registration component that configures the dependency injection container with Command Query support and Microsoft's Hybrid Cache. This enables the sample to utilize these specific patterns and caching mechanisms out of the box.

samples/EntityFramework/src/Tracker.Shared/Services · high confidence

Entity Framework Core models now automatically use sequential GUIDs for primary key properties, improving database index performance. This is achieved via a new \SequentialGuidConvention\ that configures all \Guid\ primary keys to use the \SequentialGuidGenerator\ and sets them as value-generated on add. Users can enable this behavior by registering the convention in their \DbContext\ configuration.

src/Arbiter.CommandQuery.EntityFramework/Conventions · high confidence

The Tracker.Client sample now uses a dedicated ServiceRegistration class to configure its dependency injection container. This registration sets up Blazor controls, Arbiter components, and JSON serialization options. Crucially, it enables protocol selection based on the hosting environment: when running as WebAssembly, it registers a MessagePack dispatcher with a progress bar HTTP handler, while Server-side execution uses the standard server dispatcher.

samples/EntityFramework/src/Tracker.Client/Services · high confidence

The templates in the templates directory have been updated to generate code for the Arbiter Command Query framework. New or modified templates include DomainJsonContext.csx for System.Text.Json source generation, DomainServiceRegistration.csx for DI registration, EntityEndpoint.csx for endpoint classes, EntityMapper.csx and MapperProfile.csx for mapping profiles using Riok.Mapperly.Abstractions and Arbiter.Mapping, EntityMapping.csx for expression-based mapping inheriting from MapperBase, and EntityStore.csx for scoped store classes. These changes reflect the addition of the Arbiter.Mapping generator and updates to the mapping infrastructure.

templates · high confidence

Added Entity Framework integration tests for the Tracker domain; Added Entity Framework integration tests with database initialization and mocking infrastructure; Added MediatR benchmark suite; Added MongoDB integration test infrastructure; Added MongoDB test data models and repositories; Added acceptance tests for Audit, Priority, and Task entities; Added acceptance tests for Entity Framework Core command/query operations; Added benchmark tests for CsvWriter performance; Added benchmark tests for services; Added benchmark tests for the Arbiter mediator domain; Added benchmarks for LinqExpressionBuilder filter logic; Added comprehensive unit tests for Arbiter.Services utilities; Added integration tests for Entity Framework DispatcherDataService; Added mapping performance benchmarks; Added test coverage for Azure Service Bus messaging and background queue infrastructure; Added test coverage for command constructors, extension utilities, and identity services; Added test domain scaffolding for MongoDB integration; Added test models for domain entities and DTOs; Added test suite for Arbiter.Communication email and SMS providers; Added test suite for Web PubSub messaging integration; Added tests for Arbiter.Mapping analyzer, base mappers, and generated mapper writer; Added tests for Dispatcher Client state management and test infrastructure; Added tests for FluentValidationAdapter in MongoDB command/query tests; Added tests for SequentialGuidGenerator; Added tests for diagnostics endpoint configuration and request logging middleware; Added tests for mediator pipeline behaviors and telemetry; Added tests for serialization converters and MessagePack support; Added unit tests for Arbiter.Components base classes; Added unit tests for OpenTelemetry log query handling and KQL generation; Added unit tests for query filter, sort, and serialization logic.

The project has upgraded its target framework to .NET 10 across all source, test, and sample projects, with continued support for .NET 8 and 9 in shared libraries. To streamline dependency management, the solution now uses Central Package Management via a new Directory.Packages.props file, which defines versions for all NuGet packages. This update also includes significant version bumps for key dependencies such as Microsoft.Identity.Web (4.14.2), Scalar.AspNetCore (2.17.6), and TUnit (1.68.17).

(dependencies) · high confidence

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

• CAI 59 → 56 (-3.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 85 → 80 (-5.6)
• Architecture 95 → 87 (-7.6)
• Maturity 72 → 73 (+1.6)
• Readiness 51 → 51 (-0.3)
• Security 56 → 48 (-8.4)
• Domain Modelling 100 → 97 (-3.1)
• Event-Driven 66 → 66 (+0.0)
• Performance 92 → 85 (-6.5)

• BarePragmaDisable (src/Arbiter.Mapping.Generators/MapperAnalyzer.cs)
• BarePragmaDisable (src/Arbiter.Mapping.Generators/MapperGenerator.cs)
• BarePragmaDisable (src/Arbiter.Mapping.Generators/MapperWriter.cs)
• BarePragmaDisable repeated across 77 files (samples/EntityFramework/src/Tracker.Core/Domain/Priority/Mapping/PriorityMapper.cs)
• BareSuppressMessage (src/Arbiter.Messaging.ServiceBus/ServiceBusBackgroundProcessor.cs)
• Bounded contexts not declared
• Change coupling clique: EntityCreateCommand.cs, EntityPatchCommand.cs, EntityUpdateCommand.cs (src/Arbiter.CommandQuery/Commands/EntityCreateCommand.cs)
• Duplicated block (10 lines × 2) (samples/EntityFramework/src/Tracker.Shared/Extensions/JsonSerializerOptionsExtensions.cs)
• Duplicated block (11 lines × 2) (src/Arbiter.Messaging.ServiceBus/ServiceBusQueueHealthCheck.cs)
• Duplicated block (12 lines × 2) (src/Arbiter.CommandQuery.EntityFramework/Handlers/EntityPagedQueryHandler.cs)
• Duplicated block (12 lines × 2) (src/Arbiter.Mapping.Generators/MapperAnalyzer.cs)
• Duplicated block (13 lines × 2) (src/Arbiter.Communication/Extensions/StringExtensions.cs)
• Duplicated block (13 lines × 2) (src/Arbiter.Messaging.ServiceBus/ServiceBusExtensions.cs)
• Duplicated block (14 lines × 2) (src/Arbiter.CommandQuery.Mvc/EntityExportCommandControllerBase.cs)
• Duplicated block (14 lines × 2) (src/Arbiter.CommandQuery.Mvc/EntityExportCommandControllerBase.cs)
• Duplicated block (15 lines × 3) (src/Arbiter.Communication.Azure/AzureEmailDeliveryService.cs)
• Duplicated block (17 lines × 2) (src/Arbiter.CommandQuery.EntityFramework/Handlers/EntityCreateCommandHandler.cs)
• Duplicated block (18 lines × 2) (samples/EntityFramework/src/Tracker.Service/Program.cs)
• Duplicated block (18 lines × 2) (src/Arbiter.CommandQuery.EntityFramework/Handlers/EntityPagedQueryHandler.cs)
• Duplicated block (8 lines × 2) (src/Arbiter.CommandQuery/Queries/LinqExpressionBuilder.cs)
• …and 20 more

• Base62.DecodeFromCharsCore (cognitive 23) (src/Arbiter.Services/Base62.cs)
• Base62.DecodeFromUtf8Core (cognitive 23) (src/Arbiter.Services/Base62.cs)
• CoverageExclusion (src/Arbiter.Mapping.Generators/Infrastructure/EquatableArray.cs)
• CoverageExclusion (src/Arbiter.Mapping.Generators/Infrastructure/EquatableArray.cs)
• CoverageExclusion (src/Arbiter.Mapping.Generators/Infrastructure/IndentedStringBuilder.cs)
• Documentation: no architecture or design documentation (docs/guide/dispatcher/state.md)
• Documentation: no architecture or design documentation (docs/guide/endpoints/controller.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (docs/guide/commandQuery.md)
• Documentation: no usage examples (README.md)
• Documentation: no usage examples (docs/guide/commandQuery.md)
• Duplicated block (10 lines × 2) (samples/EntityFramework/src/Tracker.Shared/Extensions/StringExtensions.cs)
• Duplicated block (10 lines × 2) (src/Arbiter.CommandQuery.Endpoints/EntityQueryEndpointBase.cs)
• Duplicated block (10 lines × 2) (src/Arbiter.Dispatcher.Client/DispatcherDataService.cs)
• Duplicated block (10 lines × 2) (src/Arbiter.Services/Base32.cs)
• Duplicated block (10 lines × 2) (src/Arbiter.Services/Base32.cs)
• Duplicated block (11 lines × 2) (samples/EntityFramework/src/Tracker.Shared/Extensions/JsonSerializerOptionsExtensions.cs)
• Duplicated block (11 lines × 2) (src/Arbiter.CommandQuery.Endpoints/BaseAddressResolver.cs)
• Duplicated block (11 lines × 2) (src/Arbiter.CommandQuery.Endpoints/ProblemDetailsCustomizer.cs)
• Duplicated block (11 lines × 2) (src/Arbiter.Components/Abstracts/EditPageBase.cs)
• …and 161 more

• 64 commits — 64 feature/other, 0 fixes

• (root) — 20 commits
• (repo) — 17 commits
• samples/EntityFramework — 4 commits
• src/Arbiter.CommandQuery — 4 commits
• src/Arbiter.CommandQuery.Endpoints — 4 commits
• src/Arbiter.Messaging.ServiceBus — 3 commits
• src/Arbiter.Messaging.WebPubSub — 2 commits
• src/Arbiter.Services — 2 commits
• docs/guide — 1 commit
• plugins/arbiter-skills — 1 commit
• src/Arbiter.Communication.Twilio — 1 commit
• src/Arbiter.Components — 1 commit
• src/Arbiter.Dispatcher.Server — 1 commit
• src/Arbiter.OpenTelemetry.Server — 1 commit
• test/Arbiter.Benchmarks — 1 commit
• test/Arbiter.Components.Tests — 1 commit

• change: Add Arbiter component base classes
• change: Add Arbiter.Components guide docs
• change: Add Arbiter.Messaging.WebPubSub package
• change: Add Base32 and Base62 encoders with tests
• change: Add ClaimResult with headers and cookies
• change: Add NestedListPageBase with core list behaviors
• change: Add RunInBackground and non-blocking cache publish
• change: Add Service Bus subscription suffix
• change: Add Snowflake ID generator
• change: Add Web PubSub health check support
• change: Add claims helpers and typed principal resolution
• change: Add diagnostic API routes
• change: Add health check UI page and cache tag support
• change: Add request context to commands and dispatch
• change: Add telemetry spans for messaging transports
• change: Add token code generation and hashing
• change: Bump LoreSoft.Blazor.Controls from 13.9.6 to 13.9.9
• change: Bump LoreSoft.Blazor.Controls from 13.9.9 to 13.10.0
• change: Bump MailKit from 4.17.0 to 4.18.0
• change: Bump Meziantou.Analyzer from 3.0.176 to 3.0.190
• …and 44 more

• 4 added · 0 removed (a removed endpoint is potentially breaking)

• GET /cache-clear
• GET /claims-check
• GET /config-debugger
• GET /health-check

• Containers 6 added · 0 removed · contexts 5 added · 0 removed · edges 3 added · 0 removed

• cache:Cache
• database:Database
• queue:Message bus
• web-api:Arbiter.Mediation(net10.0)
• web-api:Arbiter.Mediation(net8.0)
• web-api:Arbiter.Mediation(net9.0)

• Arbiter.Benchmarks
• Arbiter.CommandQuery
• Arbiter.Communication
• Arbiter.Messaging.WebPubSub
• samples

• Arbiter.Benchmarks → Arbiter.CommandQuery
• Arbiter.Messaging.WebPubSub → Arbiter.CommandQuery
• samples → Arbiter.CommandQuery

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

loresoft/Arbiter 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.