JVM and .NET HTTP

plugins {
    kotlin("jvm") version "2.3.0"
    kotlin("plugin.spring") version "2.3.0"
    id("org.springframework.boot") version "3.5.16"
}

group = "larkfield"
version = "0.1.0"

java {
    sourceCompatibility = JavaVersion.VERSION_17
}

repositories {
    mavenCentral()
}

dependencies {
    implementation(platform("org.springframework.boot:spring-boot-dependencies:3.5.16"))
    implementation("world.chio:chio-spring-boot:0.2.0")
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
    implementation("org.jetbrains.kotlin:kotlin-reflect")

    testImplementation(platform("org.springframework.boot:spring-boot-dependencies:3.5.16"))
    testImplementation("org.springframework.boot:spring-boot-starter-test")
    testImplementation("org.jetbrains.kotlin:kotlin-test-junit5")
}

tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
    compilerOptions {
        freeCompilerArgs.add("-Xjsr305=strict")
        jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17)
    }
}

tasks.withType<Test> {
    useJUnitPlatform()
}

package larkfield.pricing

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.boot.web.servlet.FilterRegistrationBean
import org.springframework.context.annotation.Bean
import org.springframework.core.Ordered
import world.chio.ChioFilter
import world.chio.ChioFilterConfig

@SpringBootApplication
class PricingApplication {
    @Bean
    fun bodyLimit() = FilterRegistrationBean<BodyLimit>().apply {
        filter = BodyLimit()
        addUrlPatterns("/v1/*")
        order = Ordered.HIGHEST_PRECEDENCE
    }

    @Bean
    fun chioFilter() = FilterRegistrationBean<ChioFilter>().apply {
        filter = ChioFilter(ChioFilterConfig(
            sidecarUrl = System.getenv("CHIO_SIDECAR_URL") ?: "http://127.0.0.1:9102"
        ))
        addUrlPatterns("/v1/*")
        order = Ordered.HIGHEST_PRECEDENCE + 1
    }
}

fun main(args: Array<String>) {
    runApplication<PricingApplication>(*args) {
        setDefaultProperties(mapOf("server.address" to "127.0.0.1", "server.port" to "8103"))
    }
}

package larkfield.pricing

import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.fasterxml.jackson.module.kotlin.readValue
import jakarta.servlet.http.HttpServletResponse
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.ExceptionHandler
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RestController
import java.math.BigDecimal
import java.math.RoundingMode
import java.nio.file.FileSystems
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.StandardCopyOption
import java.nio.file.attribute.PosixFilePermissions

class InvalidQuote(message: String) : IllegalArgumentException(message)
data class Quote(val id: Int, val sku: String, val percent: Double, val price: String, val currency: String = "USD")

// Larkfield list prices, as main holds them after the Quickstart.
val prices = mapOf("sku-118" to BigDecimal("24.00"), "sku-204" to BigDecimal("58.00"), "sku-301" to BigDecimal("140.00"))

class QuoteStore {
    private val mapper = jacksonObjectMapper()
    private val path = Path.of(".pricing/spring-quotes.json")
    private var quotes: List<Quote>
    init {
        if (FileSystems.getDefault().supportedFileAttributeViews().contains("posix")) {
            Files.createDirectories(path.parent, PosixFilePermissions.asFileAttribute(
                PosixFilePermissions.fromString("rwx------")
            ))
        } else { Files.createDirectories(path.parent) }
        quotes = if (Files.exists(path)) mapper.readValue(Files.readString(path)) else emptyList()
    }
    @Synchronized fun list(): List<Quote> = quotes.toList()
    @Synchronized fun issue(sku: String, percent: Double): Quote {
        val list = prices[sku] ?: throw InvalidQuote("unknown sku $sku")
        if (percent < 0 || percent > 100) throw InvalidQuote("percent must be between 0 and 100")
        val factor = BigDecimal.ONE - BigDecimal.valueOf(percent).divide(BigDecimal(100))
        val price = (list * factor).setScale(2, RoundingMode.HALF_UP).toPlainString()
        val quote = Quote(quotes.size + 1, sku, percent, price)
        val next = quotes + quote
        val temporary = Files.createTempFile(path.parent, "spring-quotes-", ".tmp")
        try {
            Files.writeString(temporary, mapper.writerWithDefaultPrettyPrinter().writeValueAsString(next))
            Files.move(temporary, path, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE)
        } finally { Files.deleteIfExists(temporary) }
        quotes = next
        return quote
    }
}

@RestController
class QuoteController {
    private val store = QuoteStore()
    @GetMapping("/healthz")
    fun health() = mapOf("status" to "ready", "framework" to "spring")
    @GetMapping("/v1/quotes")
    fun list() = mapOf("quotes" to store.list())
    @PostMapping("/v1/quote")
    fun quote(@RequestBody payload: JsonNode, response: HttpServletResponse): ResponseEntity<Any> {
        if (!payload.isObject || payload.size() != 2 || payload.get("sku")?.isTextual != true
            || payload.get("percent")?.isNumber != true) {
            throw InvalidQuote("body must contain exactly sku and percent")
        }
        val quote = store.issue(payload.get("sku").asText(), payload.get("percent").asDouble())
        return ResponseEntity.status(HttpStatus.CREATED).body(mapOf(
            "id" to quote.id, "sku" to quote.sku, "percent" to quote.percent,
            "price" to quote.price, "currency" to quote.currency,
            "receipt_id" to response.getHeader("X-Chio-Receipt-Id")
        ))
    }
    @ExceptionHandler(InvalidQuote::class)
    fun invalid(error: InvalidQuote) = ResponseEntity.badRequest().body(mapOf("error" to error.message))
}

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Backbay.Chio.Middleware" Version="0.2.0" />
  </ItemGroup>
</Project>

using Backbay.Chio;
using System.Text.Json;

var builder = WebApplication.CreateBuilder(args);
builder.WebHost.UseUrls("http://127.0.0.1:8104");
builder.WebHost.ConfigureKestrel(options => options.Limits.MaxRequestBodySize = 8192);
builder.Services.AddChioProtection(options => {
    options.MaxRequestBodyBytes = 8192;
    options.SidecarUrl = Environment.GetEnvironmentVariable("CHIO_SIDECAR_URL")
        ?? "http://127.0.0.1:9102";
});
var app = builder.Build();
var store = new QuoteStore(".pricing/dotnet-quotes.json");
app.UseWhen(context => context.Request.Path.StartsWithSegments("/v1"), branch => {
    branch.UseChioProtection();
});
app.MapGet("/healthz", () => Results.Json(new { status = "ready", framework = "dotnet" }));
app.MapGet("/v1/quotes", () => Results.Json(new { quotes = store.List() }));
app.MapPost("/v1/quote", (JsonElement payload, HttpContext context) => {
    if (payload.ValueKind != JsonValueKind.Object || payload.EnumerateObject().Count() != 2
        || !payload.TryGetProperty("sku", out var sku) || sku.ValueKind != JsonValueKind.String
        || !payload.TryGetProperty("percent", out var percent) || percent.ValueKind != JsonValueKind.Number) {
        return Results.BadRequest(new { error = "body must contain exactly sku and percent" });
    }
    try {
        var quote = store.Issue(sku.GetString()!, percent.GetDecimal());
        return Results.Json(new {
            id = quote.Id, sku = quote.Sku, percent = quote.Percent, price = quote.Price, currency = "USD",
            receipt_id = context.Response.Headers["X-Chio-Receipt-Id"].ToString()
        }, statusCode: StatusCodes.Status201Created);
    } catch (ArgumentException error) {
        return Results.BadRequest(new { error = error.Message });
    }
});
app.Run();

record Quote(int Id, string Sku, decimal Percent, string Price);

sealed class QuoteStore {
    // Larkfield list prices, as main holds them after the Quickstart.
    static readonly Dictionary<string, decimal> Prices = new() {
        ["sku-118"] = 24.00m, ["sku-204"] = 58.00m, ["sku-301"] = 140.00m,
    };
    private readonly string path;
    private readonly object gate = new();
    private readonly JsonSerializerOptions json = new(JsonSerializerDefaults.Web) { WriteIndented = true };
    private List<Quote> quotes;

    public QuoteStore(string path) {
        this.path = path;
        var directory = Path.GetDirectoryName(path)!;
        if (OperatingSystem.IsWindows()) Directory.CreateDirectory(directory);
        else Directory.CreateDirectory(directory, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
        quotes = File.Exists(path)
            ? JsonSerializer.Deserialize<List<Quote>>(File.ReadAllText(path), json)
                ?? throw new InvalidDataException("Quotes file must contain an array")
            : new();
    }
    public Quote[] List() { lock (gate) return quotes.ToArray(); }
    public Quote Issue(string sku, decimal percent) {
        if (!Prices.TryGetValue(sku, out var list)) throw new ArgumentException($"unknown sku {sku}");
        if (percent < 0 || percent > 100) throw new ArgumentException("percent must be between 0 and 100");
        var price = Math.Round(list * (1 - percent / 100), 2, MidpointRounding.AwayFromZero).ToString("0.00");
        lock (gate) {
            var quote = new Quote(quotes.Count + 1, sku, percent, price);
            var next = quotes.Append(quote).ToList();
            var temporary = path + "." + Guid.NewGuid().ToString("N") + ".tmp";
            try {
                File.WriteAllText(temporary, JsonSerializer.Serialize(next, json));
                File.Move(temporary, path, overwrite: true);
            } finally { File.Delete(temporary); }
            quotes = next;
            return quote;
        }
    }
}