CleanArchitectureGenerator 1.0.0

CleanArchitectureGenerator

A dotnet global tool that scaffolds production-ready Clean Architecture solutions for .NET — with a single command, an interactive CLI, and your choice of database provider.

No boilerplate hunting. No wiring up layers from scratch. Run cleanarch new, answer two questions, and ship.

Features

• Interactive CLI — prompts for project name and database provider; no flags to memorise
• Single-provider output — generates a genuinely clean codebase: SQL Server or PostgreSQL, with zero dead code from the unchosen provider
• Build-verified scaffold — runs dotnet build before handing control back; a non-compiling project is never delivered
• Production patterns baked in — CQRS, Result pattern, domain events, FluentValidation, Serilog structured logging, health checks, and Scalar API docs out of the box
• EF Core migrations-ready — connection strings, schema configuration, and retry policies pre-wired for both providers
• Minimal APIs — endpoint-per-file pattern under WebApi/Endpoints/

Installation

dotnet tool install --global CleanArchitectureGenerator

Requires the .NET 10 SDK or later.

Quick Start

cleanarch new

The tool will prompt you for:

1. Project name — PascalCase, e.g. MyApp
2. Database provider — SQL Server or PostgreSQL

Your solution is scaffolded, pruned, and build-verified in the current directory under ./MyApp/.

Non-interactive usage

cleanarch new --name MyApp --provider sqlserver
cleanarch new --name MyApp --provider postgresql
cleanarch new --name MyApp --output /path/to/output

What Gets Scaffolded

Project Structure

MyApp/
├── SharedKernel/                   # Entity base, Result<T>, domain event contracts
├── MyApp.Domain/                   # Aggregates, value objects, domain events
├── MyApp.Application/              # Use cases (commands & queries), validation
├── MyApp.Contracts/                # Request/response DTOs (shared with consumers)
├── MyApp.Infrastructure/           # EF Core, migrations, domain event dispatcher
├── MyApp.WebApi/                   # Minimal API endpoints, Serilog, health checks
├── Directory.Packages.props        # Centralised NuGet version management
└── MyApp.slnx                      # Solution file

Architecture

Each layer has a single responsibility and depends only inward:

Tech Stack

Patterns

• Result pattern — all use-case handlers return Result<T> or Result; no thrown exceptions for business failures
• Domain events — aggregates raise events via Entity.Raise(IDomainEvent); DomainEventsDispatcher delivers them post-SaveChangesAsync
• Validation decorator — FluentValidation validators are automatically discovered and composed around command handlers
• Endpoint-per-file — each HTTP endpoint lives in its own sealed class implementing IEndpoint, registered via assembly scanning

Getting Started with Your Scaffolded Project

Prerequisites

• .NET 10 SDK
• dotnet tool install --global dotnet-ef
• A running SQL Server or PostgreSQL instance

1. Set the connection string

Edit MyApp.WebApi/appsettings.json:

"ConnectionStrings": {
  "LocalDb": "Server=localhost;Database=MyApp;Trusted_Connection=True;"
}

For PostgreSQL:

"ConnectionStrings": {
  "LocalDb": "Host=localhost;Database=MyApp;Username=postgres;Password=yourpassword"
}

2. Add the initial migration

dotnet ef migrations add InitialCreate \
  --project MyApp.Infrastructure \
  --startup-project MyApp.WebApi

3. Apply migrations

dotnet ef database update \
  --project MyApp.Infrastructure \
  --startup-project MyApp.WebApi

4. Run the API

dotnet run --project MyApp.WebApi

5. Explore the API

Open https://localhost:{port}/scalar for interactive API docs.

Health check endpoint: GET /health

Provider Pruning

When you select a database provider, the generator removes all traces of the unchosen provider from the scaffolded output:

The result is a codebase with no dead code, no #if directives, and no multi-provider switch statements.

Repository Layout

CleanArchitectureGenerator/     ← the CLI tool (this repo)
  CleanArchitectureGenerator.csproj
  Program.cs                    ← Spectre.Console.Cli entry point
  NewCommand.cs                 ← interactive scaffold command
  TemplateCopier.cs             ← file copy + exclusion logic
  TokenReplacer.cs              ← ordered token replacement
  ProviderPruner.cs             ← database-provider pruning
  BuildVerifier.cs              ← dotnet build verification gate
  DbProvider.cs                 ← SqlServer | PostgreSQL enum

clean-architecture/             ← sibling repo; template source
  (not bundled — read at generation time)

The generator reads the sibling clean-architecture repository as its template source. It does not bundle templates as embedded resources, which means the template can evolve independently of the tool.

Contributing

Contributions are welcome. Please open an issue before submitting a pull request for non-trivial changes.

git clone https://github.com/TheLegendCoder/CleanArchitectureGenerator
git clone https://github.com/TheLegendCoder/clean-architecture

cd CleanArchitectureGenerator
dotnet build
dotnet run --project CleanArchitectureGenerator -- new

The launchSettings.json sets the working directory to C:\Temp so generated output doesn't land inside the repo.

License

MIT © Tsholofelo