Client Integrations

using Microsoft.EntityFrameworkCore;
using StackExchange.Redis;

var builder = WebApplication.CreateBuilder(args);
builder.AddServiceDefaults();

// Names match the AppHost: AddDatabase("ordersdb") and AddRedis("cache").
builder.AddNpgsqlDbContext<OrdersDb>("ordersdb", settings =>
{
    settings.CommandTimeout = 15;
});
builder.AddRedisClient("cache");

var app = builder.Build();
app.MapDefaultEndpoints();

app.MapGet("/orders/{id:int}", async (int id, OrdersDb db, IConnectionMultiplexer redis, CancellationToken ct) =>
{
    var cache = redis.GetDatabase();
    var key = $"order-summary:{id}";
    var cached = await cache.StringGetAsync(key);
    if (cached.HasValue)
        return Results.Text(cached.ToString(), "application/json");

    var order = await db.Orders.AsNoTracking()
        .Where(o => o.Id == id)
        .Select(o => new OrderSummary(o.Id, o.CustomerId, o.Total, o.Status))
        .FirstOrDefaultAsync(ct);
    if (order is null)
        return Results.NotFound();

    var json = System.Text.Json.JsonSerializer.Serialize(order);
    await cache.StringSetAsync(key, json, TimeSpan.FromMinutes(5));
    return Results.Text(json, "application/json");
});

app.MapPost("/orders/{id:int}/cancel", async (int id, OrdersDb db, IConnectionMultiplexer redis, CancellationToken ct) =>
{
    // The retrying strategy replays this whole block, transaction included.
    var strategy = db.Database.CreateExecutionStrategy();
    var cancelled = await strategy.ExecuteAsync(async () =>
    {
        // A replay must re-read the database, not reuse entities the failed attempt modified.
        db.ChangeTracker.Clear();
        await using var tx = await db.Database.BeginTransactionAsync(ct);
        var order = await db.Orders.FirstOrDefaultAsync(o => o.Id == id, ct);
        if (order is null)
            return false;
        // The commit may have landed before the connection dropped; a replay then finds
        // the order already cancelled and reports success instead of a false 409.
        if (order.Status == "Cancelled")
            return true;
        if (order.Status != "Placed")
            return false;
        order.Status = "Cancelled";
        db.StockReleases.Add(new StockRelease { OrderId = id, ReleasedAt = DateTimeOffset.UtcNow });
        await db.SaveChangesAsync(ct);
        await tx.CommitAsync(ct);
        return true;
    });
    if (!cancelled)
        return Results.Conflict();

    await redis.GetDatabase().KeyDeleteAsync($"order-summary:{id}");
    return Results.NoContent();
});

app.Run();

public sealed record OrderSummary(int Id, string CustomerId, decimal Total, string Status);

public sealed class Order
{
    public int Id { get; set; }
    public required string CustomerId { get; set; }
    public decimal Total { get; set; }
    public string Status { get; set; } = "Placed";
}

public sealed class StockRelease
{
    public int Id { get; set; }
    public int OrderId { get; set; }
    public DateTimeOffset ReleasedAt { get; set; }
}

public sealed class OrdersDb(DbContextOptions<OrdersDb> options) : DbContext(options)
{
    public DbSet<Order> Orders => Set<Order>();
    public DbSet<StockRelease> StockReleases => Set<StockRelease>();
}

// Stand-ins for the ServiceDefaults project this API references.
public static class ServiceDefaultsStandIn
{
    public static WebApplicationBuilder AddServiceDefaults(this WebApplicationBuilder builder) => builder;
    public static WebApplication MapDefaultEndpoints(this WebApplication app) => app;
}