WedaTemplate/
├── src/
│   ├── Weda.Core/                    # Shared infrastructure (DDD, CQRS, NATS, Cache, SAGA)
│   ├── Weda.Template.Api/            # REST API layer
│   ├── Weda.Template.Application/    # Application/CQRS layer
│   ├── Weda.Template.Contracts/      # DTOs and contracts
│   ├── Weda.Template.Domain/         # Domain layer
│   └── Weda.Template.Infrastructure/ # Infrastructure layer
├── tests/
│   ├── Weda.Template.Api.IntegrationTests/
│   ├── Weda.Template.Application.UnitTests/
│   ├── Weda.Template.Domain.UnitTests/
│   ├── Weda.Template.Infrastructure.UnitTests/
│   └── Weda.Template.TestCommon/
└── tools/
    └── WikiGenerator/

dotnet run --project src/Weda.Template.Api

[ApiVersion("1")]
public class EmployeeEventController : EventController
{
    // Request-Reply pattern with subject-based routing
    [Subject("[controller].v{version:apiVersion}.{id}.get")]
    public async Task<GetEmployeeResponse> GetEmployee(int id)
    {
        var query = new GetEmployeeQuery(id);
        var result = await Mediator.Send(query);
        return new GetEmployeeResponse(result.Value);
    }

    // Create employee
    [Subject("[controller].v{version:apiVersion}.create")]
    public async Task<GetEmployeeResponse> CreateEmployee(CreateEmployeeRequest request)
    {
        var command = new CreateEmployeeCommand(request.Name, request.Email, ...);
        var result = await Mediator.Send(command);
        return new GetEmployeeResponse(result.Value);
    }

    // JetStream Consume pattern (fire-and-forget)
    [Subject("[controller].v{version:apiVersion}.created")]
    public async Task OnEmployeeCreated(CreateEmployeeNatsEvent @event)
    {
        var command = new CreateEmployeeCommand(@event.Name, @event.Email, ...);
        await Mediator.Send(command);
    }
}

nats req employee.v1.1.get ''

nats req employee.v1.getAll ''

nats req employee.v1.create '{"name":"John Doe","email":"john@example.com","department":"Engineering","position":"Software Engineer"}'

nats req employee.v1.1.update '{"name":"John Doe","email":"john.doe@example.com","department":"Engineering","position":"Senior Engineer","status":"Active"}'

nats req employee.v1.1.delete ''

{
  "Database": {
    "Provider": "Sqlite",
    "ConnectionString": "Data Source=Weda.Template.sqlite"
  }
}

{
  "JwtSettings": {
    "Secret": "your-secret-key-at-least-32-characters",
    "TokenExpirationInMinutes": 60,
    "Issuer": "WedaTemplate",
    "Audience": "WedaTemplate"
  }
}

{
  "Nats": {
    "Url": "nats://localhost:4222",
    "Name": "weda-template"
  }
}

{
  "EmailSettings": {
    "EnableEmailNotifications": false,
    "DefaultFromEmail": "your-email@example.com",
    "SmtpSettings": {
      "Server": "smtp.gmail.com",
      "Port": 587,
      "Username": "your-email@gmail.com",
      "Password": "your-password"
    }
  }
}

[Authorize(Roles = "Admin")]
public record GetUserQuery(Guid Id) : IAuthorizeableRequest<ErrorOr<User>>;

[Authorize(Permissions = "users:read")]
public record ListUsersQuery : IAuthorizeableRequest<ErrorOr<List<User>>>;

[Authorize(Policies = "SelfOrAdmin")]
public record UpdateUserCommand(Guid Id, ...) : IAuthorizeableRequest<ErrorOr<User>>;

# Run all tests
dotnet test

# Run with coverage
dotnet test --collect:"XPlat Code Coverage"

// Inject IDistributedCache
public class MyService(IDistributedCache cache)
{
    public async Task CacheDataAsync(string key, MyData data)
    {
        var json = JsonSerializer.Serialize(data);
        await cache.SetStringAsync(key, json, new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30)
        });
    }
}

// Inject IBlobStorage
public class FileService(IBlobStorage storage)
{
    public async Task<string> UploadAsync(Stream file, string filename)
    {
        return await storage.UploadAsync(file, filename);
    }

    public async Task<Stream> DownloadAsync(string filename)
    {
        return await storage.DownloadAsync(filename);
    }
}

// Define saga steps
public class CreateOrderStep : ISagaStep<OrderSagaData>
{
    public string Name => "CreateOrder";

    public async Task<ErrorOr<OrderSagaData>> ExecuteAsync(OrderSagaData data, CancellationToken ct)
    {
        // Create order logic
        return data;
    }

    public async Task<ErrorOr<OrderSagaData>> CompensateAsync(OrderSagaData data, CancellationToken ct)
    {
        // Rollback order creation
        return data;
    }
}

// Execute saga
var result = await sagaOrchestrator.ExecuteAsync(saga, initialData);

{
  "Observability": {
    "ServiceName": "MyService",
    "Tracing": {
      "Enabled": true,
      "UseConsoleExporter": true,
      "OtlpEndpoint": "http://localhost:4317"
    },
    "Metrics": {
      "Enabled": true,
      "UseConsoleExporter": false
    }
  }
}