@dennisrongo/skills 0.1.0

package/skills/dotnet-onion-api/references/templates/feature-slice.md

@@ -0,0 +1,349 @@
+# Feature slice template — example entity `Customer`
+
+Use this for **Mode 2 (`add-feature`)**. Substitute `Customer` → `{{Feature}}` and `Customers` → folder/plural form.
+
+## 1. Domain — `src/{{Solution}}.Domain/Customers/Customer.cs`
+
+```csharp
+namespace {{Solution}}.Domain.Customers;
+
+public sealed class Customer
+{
+    public int Id { get; private set; }
+    public string Name { get; private set; } = default!;
+    public string Email { get; private set; } = default!;
+    public DateTime CreatedUtc { get; private set; }
+
+    // EF needs a parameterless ctor; keep it private.
+    private Customer() { }
+
+    public Customer(string name, string email)
+    {
+        if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Name required.", nameof(name));
+        if (string.IsNullOrWhiteSpace(email)) throw new ArgumentException("Email required.", nameof(email));
+
+        Name = name.Trim();
+        Email = email.Trim().ToLowerInvariant();
+        CreatedUtc = DateTime.UtcNow;
+    }
+
+    public void Rename(string newName)
+    {
+        if (string.IsNullOrWhiteSpace(newName)) throw new ArgumentException("Name required.", nameof(newName));
+        Name = newName.Trim();
+    }
+}
+```
+
+## 2. Application — port
+
+`src/{{Solution}}.Application/Customers/ICustomerRepository.cs`
+
+```csharp
+using {{Solution}}.Domain.Customers;
+
+namespace {{Solution}}.Application.Customers;
+
+public interface ICustomerRepository
+{
+    Task<Customer?> GetByIdAsync(int id, CancellationToken ct = default);
+    Task<IReadOnlyList<Customer>> ListAsync(CancellationToken ct = default);
+    Task AddAsync(Customer customer, CancellationToken ct = default);
+    void Remove(Customer customer);
+    Task<bool> EmailExistsAsync(string email, CancellationToken ct = default);
+}
+```
+
+## 3. Application — DTOs
+
+`src/{{Solution}}.Application/Customers/Dtos/CustomerDto.cs`
+
+```csharp
+namespace {{Solution}}.Application.Customers.Dtos;
+
+public sealed record CustomerDto(int Id, string Name, string Email, DateTime CreatedUtc);
+
+public sealed record CreateCustomerRequest(string Name, string Email);
+
+public sealed record UpdateCustomerRequest(string Name);
+```
+
+## 4. Application — service + interface
+
+`src/{{Solution}}.Application/Customers/ICustomerService.cs`
+
+```csharp
+using {{Solution}}.Application.Customers.Dtos;
+
+namespace {{Solution}}.Application.Customers;
+
+public interface ICustomerService
+{
+    Task<CustomerDto?> GetAsync(int id, CancellationToken ct = default);
+    Task<IReadOnlyList<CustomerDto>> ListAsync(CancellationToken ct = default);
+    Task<CustomerDto> CreateAsync(CreateCustomerRequest req, CancellationToken ct = default);
+    Task UpdateAsync(int id, UpdateCustomerRequest req, CancellationToken ct = default);
+    Task DeleteAsync(int id, CancellationToken ct = default);
+}
+```
+
+`src/{{Solution}}.Application/Customers/CustomerService.cs`
+
+```csharp
+using {{Solution}}.Application.Common;
+using {{Solution}}.Application.Common.Exceptions;
+using {{Solution}}.Application.Customers.Dtos;
+using {{Solution}}.Domain.Customers;
+using AutoMapper;
+
+namespace {{Solution}}.Application.Customers;
+
+public sealed class CustomerService : ICustomerService
+{
+    private readonly ICustomerRepository _repo;
+    private readonly IUnitOfWork _uow;
+    private readonly IMapper _mapper;
+
+    public CustomerService(ICustomerRepository repo, IUnitOfWork uow, IMapper mapper)
+    {
+        _repo = repo;
+        _uow = uow;
+        _mapper = mapper;
+    }
+
+    public async Task<CustomerDto?> GetAsync(int id, CancellationToken ct = default)
+    {
+        var c = await _repo.GetByIdAsync(id, ct);
+        return c is null ? null : _mapper.Map<CustomerDto>(c);
+    }
+
+    public async Task<IReadOnlyList<CustomerDto>> ListAsync(CancellationToken ct = default)
+    {
+        var list = await _repo.ListAsync(ct);
+        return _mapper.Map<IReadOnlyList<CustomerDto>>(list);
+    }
+
+    public async Task<CustomerDto> CreateAsync(CreateCustomerRequest req, CancellationToken ct = default)
+    {
+        if (await _repo.EmailExistsAsync(req.Email, ct))
+            throw new ConflictException($"Customer with email '{req.Email}' already exists.");
+
+        var customer = new Customer(req.Name, req.Email);
+        await _repo.AddAsync(customer, ct);
+        await _uow.SaveChangesAsync(ct);
+
+        return _mapper.Map<CustomerDto>(customer);
+    }
+
+    public async Task UpdateAsync(int id, UpdateCustomerRequest req, CancellationToken ct = default)
+    {
+        var customer = await _repo.GetByIdAsync(id, ct)
+            ?? throw new NotFoundException(nameof(Customer), id);
+
+        customer.Rename(req.Name);
+        await _uow.SaveChangesAsync(ct);
+    }
+
+    public async Task DeleteAsync(int id, CancellationToken ct = default)
+    {
+        var customer = await _repo.GetByIdAsync(id, ct)
+            ?? throw new NotFoundException(nameof(Customer), id);
+
+        _repo.Remove(customer);
+        await _uow.SaveChangesAsync(ct);
+    }
+}
+```
+
+## 5. Application — AutoMapper profile
+
+`src/{{Solution}}.Application/Customers/Mapping/CustomerProfile.cs`
+
+```csharp
+using {{Solution}}.Application.Customers.Dtos;
+using {{Solution}}.Domain.Customers;
+using AutoMapper;
+
+namespace {{Solution}}.Application.Customers.Mapping;
+
+public sealed class CustomerProfile : Profile
+{
+    public CustomerProfile()
+    {
+        CreateMap<Customer, CustomerDto>();
+    }
+}
+```
+
+## 6. Infrastructure — EF configuration
+
+`src/{{Solution}}.Infrastructure/Persistence/EntityConfigurations/CustomerConfiguration.cs`
+
+```csharp
+using {{Solution}}.Domain.Customers;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace {{Solution}}.Infrastructure.Persistence.EntityConfigurations;
+
+public sealed class CustomerConfiguration : IEntityTypeConfiguration<Customer>
+{
+    public void Configure(EntityTypeBuilder<Customer> b)
+    {
+        b.ToTable("Customers");
+        b.HasKey(x => x.Id);
+        b.Property(x => x.Name).HasMaxLength(200).IsRequired();
+        b.Property(x => x.Email).HasMaxLength(320).IsRequired();
+        b.HasIndex(x => x.Email).IsUnique();
+        b.Property(x => x.CreatedUtc).IsRequired();
+    }
+}
+```
+
+## 7. Infrastructure — repository adapter
+
+`src/{{Solution}}.Infrastructure/Persistence/Repositories/CustomerRepository.cs`
+
+```csharp
+using {{Solution}}.Application.Customers;
+using {{Solution}}.Domain.Customers;
+using Microsoft.EntityFrameworkCore;
+
+namespace {{Solution}}.Infrastructure.Persistence.Repositories;
+
+public sealed class CustomerRepository : ICustomerRepository
+{
+    private readonly AppDbContext _db;
+    public CustomerRepository(AppDbContext db) => _db = db;
+
+    public Task<Customer?> GetByIdAsync(int id, CancellationToken ct = default) =>
+        _db.Customers.FirstOrDefaultAsync(c => c.Id == id, ct);
+
+    public async Task<IReadOnlyList<Customer>> ListAsync(CancellationToken ct = default) =>
+        await _db.Customers.AsNoTracking().OrderBy(c => c.Name).ToListAsync(ct);
+
+    public async Task AddAsync(Customer customer, CancellationToken ct = default) =>
+        await _db.Customers.AddAsync(customer, ct);
+
+    public void Remove(Customer customer) => _db.Customers.Remove(customer);
+
+    public Task<bool> EmailExistsAsync(string email, CancellationToken ct = default) =>
+        _db.Customers.AnyAsync(c => c.Email == email.ToLower(), ct);
+}
+```
+
+Also register the DbSet on `AppDbContext`:
+
+```csharp
+public DbSet<Customer> Customers => Set<Customer>();
+```
+
+## 8. Api — controller
+
+`src/{{Solution}}.Api/Controllers/CustomersController.cs`
+
+```csharp
+using {{Solution}}.Application.Common;
+using {{Solution}}.Application.Customers;
+using {{Solution}}.Application.Customers.Dtos;
+using Microsoft.AspNetCore.Mvc;
+
+namespace {{Solution}}.Api.Controllers;
+
+public sealed class CustomersController : BaseController
+{
+    private readonly ICustomerService _service;
+
+    public CustomersController(IUserContext userContext, ICustomerService service)
+        : base(userContext)
+    {
+        _service = service;
+    }
+
+    [HttpGet("{id:int}")]
+    public async Task<ActionResult<CustomerDto>> Get(int id, CancellationToken ct)
+    {
+        var dto = await _service.GetAsync(id, ct);
+        return dto is null ? NotFound() : Ok(dto);
+    }
+
+    [HttpGet]
+    public async Task<ActionResult<IReadOnlyList<CustomerDto>>> List(CancellationToken ct) =>
+        Ok(await _service.ListAsync(ct));
+
+    [HttpPost]
+    public async Task<ActionResult<CustomerDto>> Create([FromBody] CreateCustomerRequest req, CancellationToken ct)
+    {
+        var dto = await _service.CreateAsync(req, ct);
+        return CreatedAtAction(nameof(Get), new { id = dto.Id }, dto);
+    }
+
+    [HttpPut("{id:int}")]
+    public async Task<IActionResult> Update(int id, [FromBody] UpdateCustomerRequest req, CancellationToken ct)
+    {
+        await _service.UpdateAsync(id, req, ct);
+        return NoContent();
+    }
+
+    [HttpDelete("{id:int}")]
+    public async Task<IActionResult> Delete(int id, CancellationToken ct)
+    {
+        await _service.DeleteAsync(id, ct);
+        return NoContent();
+    }
+}
+```
+
+## 9. Tests — `tests/{{Solution}}.UnitTests/Customers/CustomerServiceTests.cs`
+
+```csharp
+using {{Solution}}.Application.Common;
+using {{Solution}}.Application.Common.Exceptions;
+using {{Solution}}.Application.Customers;
+using {{Solution}}.Application.Customers.Dtos;
+using {{Solution}}.Application.Customers.Mapping;
+using {{Solution}}.Domain.Customers;
+using AutoMapper;
+using FluentAssertions;
+using NSubstitute;
+using Xunit;
+
+namespace {{Solution}}.UnitTests.Customers;
+
+public class CustomerServiceTests
+{
+    private readonly ICustomerRepository _repo = Substitute.For<ICustomerRepository>();
+    private readonly IUnitOfWork _uow = Substitute.For<IUnitOfWork>();
+    private readonly IMapper _mapper;
+    private readonly CustomerService _sut;
+
+    public CustomerServiceTests()
+    {
+        var cfg = new MapperConfiguration(c => c.AddProfile<CustomerProfile>());
+        _mapper = cfg.CreateMapper();
+        _sut = new CustomerService(_repo, _uow, _mapper);
+    }
+
+    [Fact]
+    public async Task CreateAsync_persists_and_returns_dto()
+    {
+        _repo.EmailExistsAsync("a@b.com", Arg.Any<CancellationToken>()).Returns(false);
+
+        var dto = await _sut.CreateAsync(new CreateCustomerRequest("Alice", "a@b.com"));
+
+        dto.Email.Should().Be("a@b.com");
+        await _repo.Received(1).AddAsync(Arg.Any<Customer>(), Arg.Any<CancellationToken>());
+        await _uow.Received(1).SaveChangesAsync(Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task CreateAsync_throws_when_email_exists()
+    {
+        _repo.EmailExistsAsync("a@b.com", Arg.Any<CancellationToken>()).Returns(true);
+
+        var act = async () => await _sut.CreateAsync(new CreateCustomerRequest("Alice", "a@b.com"));
+
+        await act.Should().ThrowAsync<ConflictException>();
+    }
+}
+```

package/skills/dotnet-onion-api/references/templates/program-cs.md

@@ -0,0 +1,171 @@
+# `src/{{Solution}}.Api/Program.cs`
+
+Thin top-level program; all wiring is in extension methods.
+
+```csharp
+using {{Solution}}.Api.Extensions;
+using {{Solution}}.Api.Middlewares;
+using {{Solution}}.Application;
+using {{Solution}}.Infrastructure;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services
+    .AddApplication()
+    .AddInfrastructure(builder.Configuration)
+    .AddApiServices(builder.Configuration)
+    .AddJwtAuth(builder.Configuration)
+    .AddSwaggerDocs()
+    .AddCorsPolicies(builder.Configuration);
+
+var app = builder.Build();
+
+app.UseCustomExceptionHandler();
+
+if (app.Environment.IsDevelopment() || app.Environment.IsStaging())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseHttpsRedirection();
+app.UseCors();
+app.UseAuthentication();
+app.UseAuthorization();
+app.MapControllers();
+app.Run();
+
+// Expose Program for WebApplicationFactory<Program> in integration tests.
+public partial class Program;
+```
+
+## `Extensions/ApiBehaviorExtensions.cs`
+
+```csharp
+using {{Solution}}.Api.Models;
+using Microsoft.AspNetCore.Mvc;
+
+namespace {{Solution}}.Api.Extensions;
+
+public static class ApiBehaviorExtensions
+{
+    public static IServiceCollection AddApiServices(this IServiceCollection services, IConfiguration config)
+    {
+        services.AddControllers()
+            .ConfigureApiBehaviorOptions(options =>
+            {
+                options.InvalidModelStateResponseFactory = ctx =>
+                {
+                    var errors = ctx.ModelState
+                        .Where(e => e.Value?.Errors.Count > 0)
+                        .SelectMany(x => x.Value!.Errors)
+                        .Select(x => x.ErrorMessage)
+                        .ToArray();
+
+                    return new BadRequestObjectResult(new ApiValidationErrorResponse
+                    {
+                        Errors = errors,
+                        Message = "One or more validation errors occurred."
+                    });
+                };
+            });
+
+        services.AddEndpointsApiExplorer();
+        services.AddHttpContextAccessor();
+        return services;
+    }
+}
+```
+
+## `Extensions/AuthExtensions.cs`
+
+```csharp
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.IdentityModel.Tokens;
+using System.Text;
+
+namespace {{Solution}}.Api.Extensions;
+
+public static class AuthExtensions
+{
+    public static IServiceCollection AddJwtAuth(this IServiceCollection services, IConfiguration config)
+    {
+        var secret = config["AppSettings:SecretToken"]
+            ?? throw new InvalidOperationException("AppSettings:SecretToken is required.");
+
+        services
+            .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+            .AddJwtBearer(options =>
+            {
+                options.TokenValidationParameters = new TokenValidationParameters
+                {
+                    ValidateIssuerSigningKey = true,
+                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secret)),
+                    ValidateIssuer = false,
+                    ValidateAudience = false,
+                };
+            });
+
+        services.AddAuthorization();
+        return services;
+    }
+}
+```
+
+## `Extensions/SwaggerExtensions.cs`
+
+```csharp
+using Microsoft.OpenApi.Models;
+
+namespace {{Solution}}.Api.Extensions;
+
+public static class SwaggerExtensions
+{
+    public static IServiceCollection AddSwaggerDocs(this IServiceCollection services)
+    {
+        services.AddSwaggerGen(c =>
+        {
+            c.SwaggerDoc("v1", new OpenApiInfo { Title = "{{Solution}} API", Version = "v1" });
+
+            var jwt = new OpenApiSecurityScheme
+            {
+                Name = "Authorization",
+                Type = SecuritySchemeType.Http,
+                Scheme = "bearer",
+                BearerFormat = "JWT",
+                In = ParameterLocation.Header,
+                Reference = new OpenApiReference { Type = ReferenceType.SecurityScheme, Id = "Bearer" }
+            };
+            c.AddSecurityDefinition("Bearer", jwt);
+            c.AddSecurityRequirement(new OpenApiSecurityRequirement { [jwt] = Array.Empty<string>() });
+        });
+
+        return services;
+    }
+}
+```
+
+## `Extensions/CorsExtensions.cs`
+
+```csharp
+namespace {{Solution}}.Api.Extensions;
+
+public static class CorsExtensions
+{
+    public static IServiceCollection AddCorsPolicies(this IServiceCollection services, IConfiguration config)
+    {
+        var origins = config.GetSection("AppSettings:AllowedOrigins").Get<string[]>() ?? [];
+
+        services.AddCors(options =>
+        {
+            options.AddDefaultPolicy(p => p
+                .WithOrigins(origins)
+                .AllowAnyHeader()
+                .AllowAnyMethod()
+                .AllowCredentials());
+        });
+
+        return services;
+    }
+}
+```

package/skills/dotnet-onion-api/references/templates/worker-program.cs.md

@@ -0,0 +1,166 @@
+# Worker microservice template (`BackgroundService`)
+
+Use for **Mode 3 (`add-worker`)**. One worker = one `.csproj`.
+
+## `src/{{Solution}}.Workers.{{Worker}}/Program.cs`
+
+```csharp
+using {{Solution}}.Application;
+using {{Solution}}.Infrastructure;
+using {{Solution}}.Workers.{{Worker}};
+
+var builder = Host.CreateApplicationBuilder(args);
+
+builder.Services
+    .AddApplication()
+    .AddInfrastructure(builder.Configuration);
+
+builder.Services.AddHostedService<Worker>();
+
+var host = builder.Build();
+await host.RunAsync();
+```
+
+## `src/{{Solution}}.Workers.{{Worker}}/Worker.cs`
+
+Choose **one** of the two `ExecuteAsync` bodies below based on the queue technology.
+
+### Azure Service Bus (preferred for transactional queue workloads)
+
+```csharp
+using Azure.Messaging.ServiceBus;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace {{Solution}}.Workers.{{Worker}};
+
+public sealed class Worker : BackgroundService
+{
+    private readonly ILogger<Worker> _logger;
+    private readonly ServiceBusClient _client;
+    private readonly string _queueName;
+
+    public Worker(ILogger<Worker> logger, IConfiguration config)
+    {
+        _logger = logger;
+        var connString = config.GetConnectionString("ServiceBus")
+            ?? throw new InvalidOperationException("ConnectionStrings:ServiceBus required.");
+        _queueName = config["Worker:QueueName"]
+            ?? throw new InvalidOperationException("Worker:QueueName required.");
+        _client = new ServiceBusClient(connString);
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        await using var processor = _client.CreateProcessor(_queueName, new ServiceBusProcessorOptions
+        {
+            AutoCompleteMessages = false,
+            MaxConcurrentCalls = 1
+        });
+
+        processor.ProcessMessageAsync += async args =>
+        {
+            try
+            {
+                _logger.LogInformation("Received message {Id}", args.Message.MessageId);
+
+                // TODO: deserialize, call into Application service via DI scope, persist results.
+                // Use args.CancellationToken (linked to stoppingToken).
+
+                await args.CompleteMessageAsync(args.Message, args.CancellationToken);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to process message {Id}", args.Message.MessageId);
+                await args.AbandonMessageAsync(args.Message, cancellationToken: args.CancellationToken);
+            }
+        };
+
+        processor.ProcessErrorAsync += args =>
+        {
+            _logger.LogError(args.Exception, "Service Bus error from {Source}", args.ErrorSource);
+            return Task.CompletedTask;
+        };
+
+        await processor.StartProcessingAsync(stoppingToken);
+        await Task.Delay(Timeout.Infinite, stoppingToken);
+        await processor.StopProcessingAsync(CancellationToken.None);
+    }
+
+    public override async Task StopAsync(CancellationToken cancellationToken)
+    {
+        await _client.DisposeAsync();
+        await base.StopAsync(cancellationToken);
+    }
+}
+```
+
+### Azure Storage Queue (when there's no Service Bus)
+
+```csharp
+using Azure.Storage.Queues;
+using Azure.Storage.Queues.Models;
+
+protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+{
+    var queue = new QueueClient(_connectionString, _queueName);
+    await queue.CreateIfNotExistsAsync(cancellationToken: stoppingToken);
+
+    while (!stoppingToken.IsCancellationRequested)
+    {
+        QueueMessage[] messages = await queue.ReceiveMessagesAsync(maxMessages: 10, cancellationToken: stoppingToken);
+
+        if (messages.Length == 0)
+        {
+            try { await Task.Delay(TimeSpan.FromSeconds(2), stoppingToken); }
+            catch (TaskCanceledException) { break; }
+            continue;
+        }
+
+        foreach (var msg in messages)
+        {
+            try
+            {
+                using var scope = _serviceProvider.CreateScope();
+                // Resolve scoped services here, dispatch.
+                await queue.DeleteMessageAsync(msg.MessageId, msg.PopReceipt, stoppingToken);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Worker failed processing message {Id}", msg.MessageId);
+                // Don't delete — let the queue re-deliver after the visibility timeout.
+            }
+        }
+    }
+}
+```
+
+Inject `IServiceProvider` to create a scope per message (so EF Core's scoped `AppDbContext` is fresh each iteration).
+
+## `appsettings.json`
+
+```json
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "ConnectionStrings": {
+    "Default": "",
+    "ServiceBus": ""
+  },
+  "Worker": {
+    "QueueName": ""
+  }
+}
+```
+
+## What the worker must **never** do
+
+- `while (true) { ... Task.Delay(5s); }` without checking `stoppingToken` — breaks graceful shutdown.
+- Resolve scoped services from the root provider — always create an `IServiceScope` per message.
+- Reference `{{Solution}}.Api`. Workers depend on Application + Infrastructure only.
+- Catch `Exception` and silently delete the message — that loses the failure forever.