Auderz.Shared.DevMode 1.2.0

Auderz.Shared

Building blocks for .NET 10 microservices: vertical-slice plumbing, permission-based authorization, an event backbone on Kafka with a transactional outbox, a configurable Quartz job manager, Redis caching, localisation and OpenTelemetry observability.

These packages were built for the Auderz platform and are published because they are useful on their own. They are opinionated — the conventions below are baked in rather than configurable — so they suit a service being built to fit them better than one being retrofitted.

Install

One reference gets the core set:

<PackageReference Include="Auderz.Shared" Version="1.1.0" />

Auderz.Shared is a metapackage with no code of its own. It carries a pinned dependency set: Kernel, Vsa, Authorization, Localization, Messaging, Observability, Jobs, Jobs.EntityFrameworkCore, Jobs.Api and Notifications.Abstractions.

Two packages sit deliberately outside it, because not every service should carry them:

<PackageReference Include="Auderz.Shared.Caching" Version="1.1.0" />   
<PackageReference Include="Auderz.Shared.DevMode" Version="1.1.0" />   

Auderz.Shared.DevMode replaces the email, SMS and push senders with capturing ones. Referencing it from a Release build is a service that silently stops sending real notifications, so it belongs behind an environment check or a Condition on the reference.

Packages

Requirements

• .NET 10. There is no multi-targeting and no netstandard fallback.
• SQL Server for the job manager, because Quartz's ADO job store with clustering needs it. Everything else is storage-agnostic.
• Kafka for Auderz.Shared.Messaging, Redis for Auderz.Shared.Caching — both optional at the package level and switchable off in configuration, so a service runs locally without them.

Quick start

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

builder.AddAuderzObservability();

builder.Services.AddAuderzPermissionAuthorization(builder.Configuration);
builder.Services.AddAuderzTranslations(typeof(Program).Assembly);
builder.Services.AddAuderzMessaging(builder.Configuration);
builder.Services.AddAuderzCaching(builder.Configuration);

// Handlers, validators and endpoint slices, discovered by assembly scan.
builder.Services.AddAuderzDispatcher(typeof(Program).Assembly);
builder.Services.AddAuderzEndpoints(typeof(Program).Assembly);

WebApplication app = builder.Build();

app.UseAuderzObservability();
app.UseAuthentication();
app.UseAuthorization();
app.MapAuderzEndpoints();
app.MapAuderzHealthChecks();

await app.RunAsync();

Conventions baked in

• Vertical Slice Architecture. A feature is a folder holding its own contracts, handler, repository, validators and models — not a row through Domain/Application/Infrastructure projects.
• CQRS through MediatR, behind IDispatcher. Slices name the Auderz interfaces (ICommand, IQuery<T>, IPagedQuery<T> and their handlers); MediatR does the dispatching, so it can be replaced in one file.
• All request validation is FluentValidation, run by a pipeline behaviour before any handler sees the request — so it cannot be forgotten when someone adds a slice.
• Handlers return asom.lib response types (CommandResponse, CommandResponse<T>, PagedCommandResponse<T>), built through one adapter. Domain aggregates return Result/Error and convert at the slice boundary. Paging is asom.lib's PagedDataCriteria end to end and money is its Money struct. If you do not want asom.lib in your graph, these packages are not for you — it is a hard dependency of Kernel.
• Quartz.NET 4, not 3.x. Auderz.Shared.Jobs targets the single-package Quartz 4: the DependencyInjection, Hosting and SystemTextJson extension packages were folded into Quartz, and referencing them alongside it gives you two copies of the same extension methods. IJob.Execute returns ValueTask.

Versioning

All Auderz.Shared.* packages share one version and are released together. Pin them as a set. A mixed set — Kernel 1.1.0 against Vsa 1.0.0 — does not fail at build; it fails at load with a MissingMethodException, which is a much worse afternoon.

With central package management, keep the individual PackageVersion entries alongside the metapackage and turn on CentralPackageTransitivePinningEnabled: that pins what the metapackage pulls in, so a transitive resolve cannot quietly land a different build.

Versions on nuget.org are permanent. A fix to a released version is the next patch, never a re-push.

Symbols

Symbol packages (.snupkg) are published, so a stack trace through Auderz.Shared.* gives you method names and line numbers. Source stepping is not available — the repository is private.

Licence

MIT. See the licence link on the package page.