FastEndpoints Web API

A modern, high-performance ASP.NET Core API built with FastEndpoints following vertical slice architecture principles. This project demonstrates a clean, maintainable approach to building REST APIs with minimal ceremony and maximum productivity.

🏗️ Architecture

This project follows Vertical Slice Architecture, organizing code by feature rather than technical layers:

• Features/ - Domain-driven feature folders (e.g., Features/Monkeys/) containing all related endpoints
• Common/ - Shared infrastructure including:
  • Domain models with rich behavior
  • Commands for operations with side effects
  • Events for loosely-coupled notifications
  • Middleware and preprocessors
  • Persistence layer (in-memory repository)

Key Design Patterns

• Endpoint Groups: Define route prefixes and shared configuration (MonkeyGroup → /api/monkeys)
• Rich Domain Models: Private setters with static factory methods prevent invalid state
• CQRS-lite: Commands and events via FastEndpoints' built-in mediator
• Request/Response DTOs: Immutable records for clear contracts
• FluentValidation: Auto-discovered validators with detailed error messages

🚀 Getting Started

Prerequisites

• .NET 10 SDK or later
• Any IDE (Visual Studio 2022, VS Code, Rider)

Installation

1. Clone the repository:

git clone <repository-url>
cd FastEndpoints

2. Restore dependencies:

dotnet restore

3. Run the application:

dotnet run --project FastWebApi/FastWebApi.csproj

The API will start on:

• HTTPS: https://localhost:7038
• HTTP: http://localhost:5128

4. Open Swagger UI in your browser:

https://localhost:7038/swagger

📡 API Endpoints

Monkeys API

All monkey endpoints are grouped under /api/monkeys:

Get All Monkeys

GET /api/monkeys

Response (200 OK):

{
  "monkeys": [
    {
      "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
      "name": "Bubbles",
      "age": 4,
      "temperament": "Playful"
    }
  ]
}

Create Monkey

POST /api/monkeys
Content-Type: application/json

{
  "name": "Bubbles",
  "age": 4,
  "temperament": "Playful"
}

Valid Temperament Values:

• Calm
• Playful
• Aggressive

Responses:

• 204 No Content - Monkey created successfully
• 400 Bad Request - Validation failed or monkey limit reached (max 5 monkeys)

Example with cURL:

curl -X POST https://localhost:7038/api/monkeys \
  -H "Content-Type: application/json" \
  -d '{"name":"Bubbles","age":4,"temperament":"Playful"}'

Delete Monkey

DELETE /api/monkeys/{id}

Responses:

• 204 No Content - Monkey deleted successfully
• 404 Not Found - Monkey not found

Example with cURL:

curl -X DELETE https://localhost:7038/api/monkeys/3fa85f64-5717-4562-b3fc-2c963f66afa6

🧪 Testing the API

Using Swagger UI

1. Navigate to https://localhost:7038/swagger
2. Expand any endpoint
3. Click "Try it out"
4. Fill in parameters and click "Execute"

Using HTTP Files (VS Code/Rider)

Create a file named test.http:

### Get all monkeys
GET https://localhost:7038/api/monkeys

### Create a monkey
POST https://localhost:7038/api/monkeys
Content-Type: application/json

{
  "name": "George",
  "age": 3,
  "temperament": "Calm"
}

### Delete a monkey (replace with actual ID)
DELETE https://localhost:7038/api/monkeys/3fa85f64-5717-4562-b3fc-2c963f66afa6

🏛️ Project Structure

FastWebApi/
├── Features/
│   └── Monkeys/
│       ├── CreateMonkeyEndpoint.cs     # POST endpoint with validation
│       ├── GetMonkeysEndpoint.cs       # GET endpoint
│       ├── DeleteMonkeyEndpoint.cs     # DELETE endpoint
│       └── MonkeyGroup.cs              # Route group configuration
├── Common/
│   ├── Domain/                         # Rich domain models
│   ├── Commands/                       # Command pattern implementations
│   ├── Events/                         # Event publishing/handling
│   ├── Middleware/                     # Custom middleware
│   ├── Preprocessors/                  # Request preprocessors
│   └── Persistence/                    # Repository implementations
├── Program.cs                          # Application entry point
└── GlobalUsings.cs                     # Global namespace imports

🔧 Configuration

Application Settings

Configuration is managed through appsettings.json and appsettings.Development.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  }
}

Launch Profiles

Edit Properties/launchSettings.json to customize:

• Port numbers
• Environment variables
• Launch behavior (browser, URLs, etc.)

📦 Dependencies

• FastEndpoints (7.0.1) - High-performance endpoint library
• FastEndpoints.Swagger (7.0.1) - OpenAPI/Swagger integration
• .NET 10 - Target framework

🎯 Features

• ✅ High Performance: FastEndpoints eliminates controller overhead
• ✅ Auto-Validation: FluentValidation with automatic error responses
• ✅ OpenAPI/Swagger: Interactive API documentation
• ✅ Request Logging: Global preprocessor logs all requests
• ✅ Command Pattern: Separate side effects from core logic
• ✅ Event Publishing: Loosely-coupled event handlers
• ✅ Rich Domain Models: Encapsulated business logic
• ✅ Nullable Reference Types: Improved null safety

🛠️ Development Guidelines

Adding a New Endpoint

1. Create endpoint class in appropriate feature folder:

public class MyEndpoint(Dependencies deps) : Endpoint<TRequest, TResponse>
{
    public override void Configure()
    {
        Post("/route");
        Group<MyGroup>();
    }

    public override async Task HandleAsync(TRequest req, CancellationToken ct)
    {
        // Your logic here
    }
}

2. Create validator (optional):

public class MyRequestValidator : Validator<TRequest>
{
    public MyRequestValidator()
    {
        RuleFor(x => x.Property).NotEmpty();
    }
}

3. Endpoint auto-discovered on startup - no registration needed!

Adding a Command

public record MyCommand(string Data) : ICommand;

public class MyCommandHandler : ICommandHandler<MyCommand>
{
    public async Task ExecuteAsync(MyCommand cmd, CancellationToken ct)
    {
        // Side effect logic (email, external API, etc.)
    }
}

Publishing Events

await new MyEvent(data).PublishAsync(Mode.WaitForAll, ct);

📝 Additional Resources

• FastEndpoints Documentation
• Vertical Slice Architecture
• FluentValidation Documentation

🤝 Contributing

When contributing, follow these patterns:

• Keep endpoints focused on single responsibility
• Use rich domain models with private setters
• Separate side effects into commands
• Use events for cross-cutting concerns
• Write validators for all request types
• Include Swagger summaries for documentation