MachinaXX.Chassis 0.0.1

MachinaXX.Chassis

A core library for building standardized ASP.NET Core APIs with common patterns and configurations.

Installation

dotnet add package MachinaXX.Chassis

Quick Start

The simplest way to use the library is with the CreateStandardApi extension method:

using MachinaXX.API.Builder;

var app = args.CreateStandardApi();
app.Run();

This creates an API with:

• JWT authentication
• Swagger documentation
• CORS configuration
• Standard endpoints (/health, /version)
• Common middleware

Customizing Your API

Adding Custom Services

var app = args.CreateStandardApi(
    configureBuilder: builder =>
    {
        // Register your services
        builder.Builder.Services.AddSingleton<IMyService, MyService>();
        
        // Customize auth settings
        builder.AddAuth(options => 
        {
            options.ConfigureAuthorization = auth =>
            {
                auth.AddPolicy("MyCustomPolicy", policy => 
                    policy.RequireRole("SpecialRole"));
            };
        });
    });

Adding Custom Routes and Endpoints

var app = args.CreateStandardApi(
    configureApp: app =>
    {
        // Add custom routes
        app.MapGet("/api/custom", () => "My custom endpoint")
            .RequireAuthorization("APIUser");
            
        // Or use extension method to organize routes
        app.ConfigureMyFeatureRoutes();
    });

Using Vertical Slice Architecture

The library is designed to work well with vertical slice architecture:

// Register services from specific assemblies
builder.AddVerticalServices(typeof(MyFeature), typeof(AnotherFeature));

// When using Carter for endpoint organization
app.MapCarter();

Database Access

// Register the data access service
builder.Builder.Services.AddSingleton<ISqlDataAccess, SqlDataAccess>();

// Inject and use in your services
public class MyService
{
    private readonly ISqlDataAccess _db;
    
    public MyService(ISqlDataAccess db)
    {
        _db = db;
    }
    
    public async Task<IEnumerable<MyEntity>> GetAllAsync()
    {
        return await _db.QueryAsync<MyEntity>("SELECT * FROM MyEntities");
    }
}

Database Migrations

// Add the migration service
builder.Builder.Services.AddMigrations(
    typeof(MyFeature).Assembly, // Assembly containing migration scripts
    typeof(AnotherFeature).Assembly);

Customizing Core Components

If you need more control, you can use the ApiBuilder directly:

var builder = new ApiBuilder(args);

// Add only what you need
builder
    .AddAuth()
    .AddSwagger()
    .AddCors(options => 
    {
        options.AllowAnyOrigin = true;
        options.AllowCredentials = true;
    })
    .AddVerticalServices(typeof(Program));
    
// Build and configure the app
var app = builder.Build();

// Configure middleware
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.Run();

Publishing to NuGet

1. Update version in the .csproj file
2. Build the package:

   dotnet pack -c Release
   

3. Push to NuGet:

   dotnet nuget push bin/Release/MachinaXX.API.{version}.nupkg --api-key {your-api-key} --source https://api.nuget.org/v3/index.json
   

Versioning Strategy

This library follows Semantic Versioning:

• MAJOR version for incompatible API changes
• MINOR version for backward-compatible functionality
• PATCH version for backward-compatible bug fixes