Zeta 0.1.16

Zeta

Zeta is a schema-first validation framework for .NET with a fluent, async-first API.

using Zeta;

var schema = Z.Schema<User>()
    .Property(x => x.Email, s => s.Email())
    .Property(x => x.Age, s => s.Min(18));

var result = await schema.ValidateAsync(new User("alice@example.com", 21));

if (!result.IsSuccess)
{
    foreach (var error in result.Errors)
        Console.WriteLine($"{error.PathString}: {error.Message}");
}

public sealed record User(string Email, int Age);

Quick Start

dotnet add package Zeta

# Optional: ASP.NET Core integration (Minimal APIs / Controllers)
dotnet add package Zeta.AspNetCore

# Optional: FastEndpoints integration
dotnet add package Zeta.FastEndpoints

Core Examples

1. Minimal API Validation

using Zeta;
using Zeta.AspNetCore;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddZeta();
var app = builder.Build();

var createUserSchema = Z.Schema<CreateUserRequest>()
    .Property(x => x.Email, s => s.Email())
    .Property(x => x.Name, s => s.MinLength(2));

app.MapPost("/users", (CreateUserRequest request) => Results.Ok(request))
    .WithValidation(createUserSchema);

app.Run();

public sealed record CreateUserRequest(string Email, string Name);

2. Context-Aware Rules with .Using(...)

var registerSchema = Z.Schema<RegisterRequest>()
    .Using<RegisterContext>(async (input, sp, ct) =>
    {
        var repo = sp.GetRequiredService<IUserRepository>();
        var exists = await repo.EmailExistsAsync(input.Email, ct);
        return new RegisterContext(exists);
    })
    .Property(x => x.Email, s => s.Email())
    .Refine((x, ctx) => !ctx.EmailExists, "Email already exists", "email_exists");

public sealed record RegisterRequest(string Email);
public sealed record RegisterContext(bool EmailExists);

3. Collection Validation with .Each(...)

var orderSchema = Z.Schema<CreateOrderRequest>()
    .Property(x => x.Items, items => items
        .Each(i => i
            .Property(v => v.ProductId, s => s.NotEmpty())
            .Property(v => v.Quantity, s => s.Min(1)))
        .MinLength(1));

public sealed record CreateOrderRequest(List<OrderItem> Items);
public sealed record OrderItem(string ProductId, int Quantity);

This repository contains:

• Core package source: src/Zeta
• ASP.NET Core integration package source: src/Zeta.AspNetCore
• FastEndpoints integration package source: src/Zeta.FastEndpoints
• Source generators: src/Zeta.SourceGenerators
• Tests: tests
• Samples: samples
• Benchmarks: benchmarks

Package Documentation

• Core validation package (Zeta): src/Zeta/README.md
• ASP.NET Core integration package (Zeta.AspNetCore): src/Zeta.AspNetCore/README.md
• FastEndpoints integration package (Zeta.FastEndpoints): src/Zeta.FastEndpoints/README.md
• Guides: docs

Which package should I use?

• Zeta: Use in any .NET app (Console, Worker, Blazor, MAUI, libraries).
• Zeta.AspNetCore: Add only when you need ASP.NET Core integration (Minimal APIs, Controllers, validation filters).
• Zeta.FastEndpoints: Add when you use FastEndpoints as your web framework.

Build and Test

dotnet build
dotnet test

Samples

# ASP.NET Core sample
dotnet run --project samples/Zeta.Sample.Api

# Blazor sample
dotnet run --project samples/Zeta.Sample.Blazor

# FastEndpoints sample
dotnet run --project samples/Zeta.Sample.FastEndpoints.Api

Benchmarks

Comparing Zeta against FluentValidation and DataAnnotations on .NET 10 (Apple M2 Pro).

Key findings:

• Allocates 64% less memory than FluentValidation on valid input (216 B vs 600 B)
• Allocates 7.4x less memory than FluentValidation on invalid input (1,048 B vs 7,728 B)
• 4.4x faster than FluentValidation when validation fails (442 ns vs 1,924 ns)
• 2.2x faster than DataAnnotations when validation fails (442 ns vs 991 ns)

Run benchmarks:

dotnet run --project benchmarks/Zeta.Benchmarks -c Release

Changelog

See CHANGELOG.md.