UnionRailway

// One-line DI setup
builder.Services.AddRailway(options =>
{
    // Global ProblemDetails enrichment — applied to ALL error responses
    options.ConfigureProblem = pd =>
        pd.Extensions["traceId"] = Activity.Current?.Id;
});

// Or with a custom mapper:
builder.Services.AddRailway<CustomErrorMapper>();

// Global exception middleware (add early in pipeline)
app.UseRailwayExceptionHandler();

// ── Option A: .ToHttpResult() per endpoint ──────────────────────────────
app.MapGet("/users/{id:int}", async (int id, UserService svc) =>
    (await svc.GetUserAsync(id)).ToHttpResult());

// POST: returns 201 Created with Location header
app.MapPost("/users", async (CreateUserRequest req, UserService svc) =>
    (await svc.CreateAsync(req)).ToHttpResult(createdUri: $"/users/{req.Id}"))
    .WithCreatedRailOpenApi<RouteHandlerBuilder, UserDto>();

// DELETE: Rail<Unit> → 204 No Content automatically
app.MapDelete("/users/{id}", async (int id, UserService svc) =>
    (await svc.DeleteAsync(id)).ToHttpResult());

// Inline ProblemDetails customisation
return result.ToHttpResult(configureProblem: pd =>
{
    pd.Extensions["traceId"] = Activity.Current?.Id;
    if (env.IsProduction())
        pd.Detail = "An error occurred.";
});

// ── Option B: Zero-boilerplate endpoint filter ───────────────────────────
var api = app.MapGroup("/api").WithRailwayFilter();

api.MapGet("/users/{id}",
    async (int id, UserService svc) =>
        await svc.GetUserAsync(id));   // Rail<User> → 200 / 404 auto

api.MapDelete("/users/{id}",
    async (int id, UserService svc) =>
        await svc.DeleteAsync(id));    // Rail<Unit> → 204 auto

// ── Option C: Custom error mapper ───────────────────────────────────────
public class CustomErrorMapper : IUnionErrorMapper
{
    public IResult? TryMap(UnionError error) => error.Value switch
    {
        UnionError.NotFound nf => Results.Problem(
            detail: $"Could not locate '{nf.Resource}'.",
            statusCode: 404, title: "Resource Not Found"),
        UnionError.Custom { Code: "RATE_LIMIT" } c => Results.Problem(
            detail: c.Message, statusCode: 429, title: "Rate Limited"),
        _ => null   // fall back to default RFC 7807 mapping
    };
}

// Install: dotnet add package UnionRailway.EntityFrameworkCore

// ── FirstOrDefaultAsUnionAsync ───────────────────────────────────────────
// Replaces: var user = await db.Users.FirstOrDefaultAsync(...);
//           if (user == null) return NotFound();

Rail<User> user = await db.Users
    .FirstOrDefaultAsUnionAsync("User", x => x.Id == id);
// ✅ Returns NotFound("User") automatically when null

// With cancellation token
Rail<User> user = await db.Users
    .FirstOrDefaultAsUnionAsync("User", x => x.Id == id, cancellationToken);

// ── SaveChangesAsUnionAsync ──────────────────────────────────────────────
// Returns Rail<int> (rows affected), wraps DbUpdateException → SystemFailure

Rail<int> saved = await db.SaveChangesAsUnionAsync();
if (!saved.IsSuccess(out var rows, out var err))
    return err.GetValueOrDefault().ToHttpResult();

Console.WriteLine($"{rows} row(s) saved.");

// ── Full service example ─────────────────────────────────────────────────
public class ProductService(AppDbContext db)
{
    public async ValueTask<Rail<Product>> GetProductAsync(int id) =>
        await db.Products.FirstOrDefaultAsUnionAsync("Product", p => p.Id == id);

    public async ValueTask<Rail<Unit>> UpdateProductAsync(int id, UpdateDto dto)
    {
        var product = await db.Products.FirstOrDefaultAsUnionAsync("Product", p => p.Id == id);
        if (!product.IsSuccess(out var p, out var err))
            return err.GetValueOrDefault();

        p.Name = dto.Name;
        p.Price = dto.Price;
        var saved = await db.SaveChangesAsUnionAsync();
        return saved.IsSuccess(out _, out var saveErr) ? Unit.Value : saveErr.GetValueOrDefault();
    }
}

// Install: dotnet add package UnionRailway.HttpClient

// ── GET ──────────────────────────────────────────────────────────────────
Rail<UserDto> result = await httpClient
    .GetFromJsonAsUnionAsync<UserDto>("/users/42");

// Automatic mapping:
//   2xx  → Rail<T> with the deserialized body
//   404  → UnionError.NotFound
//   401  → UnionError.Unauthorized
//   403  → UnionError.Forbidden
//   409  → UnionError.Conflict
//   422  → UnionError.Validation
//   5xx  → UnionError.SystemFailure

// ── POST ─────────────────────────────────────────────────────────────────
Rail<UserDto> created = await httpClient
    .PostAsJsonAsUnionAsync<CreateUserRequest, UserDto>(
        "/users", new CreateUserRequest("Alice"));

// ── Chaining with the result ─────────────────────────────────────────────
var summary = await httpClient
    .GetFromJsonAsUnionAsync<User>("/users/42")
    .BindAsync(u => httpClient.GetFromJsonAsUnionAsync<Order[]>($"/orders?userId={u.Id}"))
    .MapAsync(orders => new OrderSummary(orders.Length));

return summary.ToHttpResult();

// ── Map: transform a successful value ────────────────────────────────────
Rail<int> doubled = Union.Ok(5).Map(x => x * 2);       // Ok(10)
Rail<int> skipped = Union.Fail<int>(err).Map(x => x * 2); // still Fail

// ── Bind: chain operations that may also fail ────────────────────────────
Rail<OrderSummary> summary =
    await GetUserAsync(id)                             // Rail<User>
        .BindAsync(u => GetOrdersAsync(u.Id))          // Rail<Order[]>
        .MapAsync(orders => new OrderSummary(orders)); // Rail<OrderSummary>

// ── Tap: side effects without altering the value ─────────────────────────
var result = await GetUserAsync(id)
    .TapAsync(u => logger.LogInformation("Accessed user {Id}", u.Id))
    .ToHttpResultAsync();   // side effect only on success path

// ── Recover: provide a fallback for specific error types ─────────────────
Rail<User> withFallback = await GetUserAsync(id)
    .RecoverAsync<User, UnionError.NotFound>(_ => guestUser);

// More selective recovery
Rail<User> partial = await GetUserAsync(id)
    .RecoverAsync<User, UnionError.Unauthorized>(_ =>
        new User { Id = 0, Name = "Anonymous" });

// ── Full chain example ────────────────────────────────────────────────────
return await GetUserAsync(id)
    .TapAsync(u => auditLog.LogAccessAsync(u.Id))
    .BindAsync(u => GetPermissionsAsync(u.Id))
    .MapAsync(perms => new UserProfile(perms))
    .RecoverAsync<UserProfile, UnionError.NotFound>(_ => UserProfile.Guest)
    .ToHttpResultAsync();

// ── Wrap exception-based legacy code ─────────────────────────────────────
Rail<Report> result = await UnionWrapper.RunAsync(
    () => legacyReportService.GenerateAsync(reportId));
// Any exception → UnionError.SystemFailure(ex)

// ── Wrap nullable-returning code ─────────────────────────────────────────
Rail<User> maybeUser = await UnionWrapper.RunNullableAsync(
    () => legacyRepo.FindByEmailAsync(email));
// null → UnionError.NotFound("value")

// ── From LanguageExt (Fin<T>) ─────────────────────────────────────────────
// Before:
Fin<User> fin = await repo.GetAsync(id);
return fin.Match(Succ: u => Results.Ok(u), Fail: e => Results.Problem(e.Message));

// After:
Rail<User> rail = await repo.GetAsync(id);  // change return type
return rail.ToHttpResult();

// ── From ErrorOr ─────────────────────────────────────────────────────────
// Before:
ErrorOr<User> eo = await repo.GetAsync(id);
if (eo.IsError) return eo.Errors[0];

// After:
Rail<User> rail = await repo.GetAsync(id);
if (!rail.IsSuccess(out var user, out var err))
    return err.GetValueOrDefault();