Add schema validation docs, Unix socket client docs, and example

Document JSON Schema validation with .schema() in README with usage
examples for required fields, enums, and nested objects. Add Unix socket
client-level configuration section. Update build options table.

Add server_schema_example.cpp demonstrating schema validation with
nested objects, enums, arrays, and curl commands to test.

Author: alvarolb

README.md

@@ -236,6 +236,52 @@ server.serve_static("/app", "/var/www/app", "app.html");
 server.serve_static("/assets", "/var/www/assets", "");
 ```
 
+### JSON Schema Validation
+
+Validate request bodies against [JSON Schema](https://json-schema.org/) using [Valijson](https://github.com/tristanpenman/valijson). Chain `.schema()` on any route to enforce validation before the handler is called. Invalid requests get a `400 Bad Request` with error details.
+
+```cpp
+server.post("/api/users", [](nlohmann::json& json, auto& res) {
+    // json is already validated against the schema
+    res.json({{"created", true}, {"name", json["name"]}});
+}).schema({
+    {"type", "object"},
+    {"required", {"name", "email"}},
+    {"properties", {
+        {"name", {{"type", "string"}}},
+        {"email", {{"type", "string"}}},
+        {"age", {{"type", "integer"}, {"minimum", 0}}}
+    }}
+});
+```
+
+Works with all JSON handler signatures and HTTP methods:
+
+```cpp
+// With request access
+server.put("/api/users/:id", [](auto& req, nlohmann::json& json, auto& res) {
+    res.json({{"updated", true}, {"id", req["id"]}});
+}).schema({
+    {"type", "object"},
+    {"properties", {
+        {"name", {{"type", "string"}}}
+    }}
+});
+
+// Enum validation
+server.post("/api/status", [](nlohmann::json& json, auto& res) {
+    res.json({{"status", json["status"]}});
+}).schema({
+    {"type", "object"},
+    {"required", {"status"}},
+    {"properties", {
+        {"status", {{"type", "string"}, {"enum", {"active", "inactive", "pending"}}}}
+    }}
+});
+```
+
+Valijson is enabled by default. Disable with `-DTHINGER_HTTP_ENABLE_VALIJSON=OFF`.
+
 ### CORS
 
 ```cpp
@@ -294,13 +340,36 @@ auto res = client.put(url, body, content_type);
 auto res = client.del(url);
 ```
 
+### Unix Socket
+
+Connect to services via Unix domain sockets (e.g., Docker, systemd). Configure once on the client — all methods work transparently:
+
+```cpp
+thinger::http::client client;
+client.unix_socket("/var/run/docker.sock");
+
+// Same API as TCP — the socket is used automatically
+auto containers = client.get("http://localhost/containers/json");
+auto result = client.post("http://localhost/containers/create",
+    R"({"Image": "nginx"})", "application/json");
+```
+
+Also available via the request builder for per-request control:
+
+```cpp
+auto res = client.request("http://localhost/containers/json")
+    .unix_socket("/var/run/docker.sock")
+    .get();
+```
+
 ### Configuration
 
 ```cpp
 client.timeout(std::chrono::seconds(30));
 client.follow_redirects(true);
 client.max_redirects(10);
 client.verify_ssl(false);  // Disable SSL verification
+client.unix_socket("/path/to/socket");  // Unix domain socket
 ```
 
 ### Request Builder (Fluent API)
@@ -663,6 +732,8 @@ thinger::logging::set_logger(logger);
 | CMake Option | Default | Description |
 |--------------|---------|-------------|
 | `THINGER_HTTP_ENABLE_LOGGING` | `ON` | Enable spdlog integration |
+| `THINGER_HTTP_ENABLE_VALIJSON` | `ON` | Enable JSON Schema validation |
+| `THINGER_HTTP_ENABLE_SSL` | `ON` | Enable SSL/TLS support |
 | `THINGER_HTTP_BUILD_TESTS` | `ON` | Build test suite |
 | `THINGER_HTTP_BUILD_EXAMPLES` | `OFF` | Build examples |
 

examples/http_server/CMakeLists.txt

@@ -48,6 +48,10 @@ target_link_libraries(server_upload_example PRIVATE thinger::http)
 add_executable(server_streaming_upload_example server_streaming_upload_example.cpp)
 target_link_libraries(server_streaming_upload_example PRIVATE thinger::http)
 
+# Server Schema Validation example (JSON Schema with Valijson)
+add_executable(server_schema_example server_schema_example.cpp)
+target_link_libraries(server_schema_example PRIVATE thinger::http)
+
 # Install examples
 install(TARGETS simple_http_server simple_https_server advanced_http_server
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}/examples

examples/http_server/server_schema_example.cpp

@@ -0,0 +1,117 @@
+#include <thinger/http_server.hpp>
+#include <iostream>
+
+using namespace thinger;
+
+// This example demonstrates JSON Schema validation on route handlers.
+// Invalid requests are automatically rejected with 400 Bad Request.
+
+int main(int argc, char* argv[]) {
+    http::server server;
+
+    // POST /api/users - Create a user with required fields
+    server.post("/api/users", [](nlohmann::json& json, http::response& res) {
+        // json is already validated — guaranteed to have name and email as strings
+        res.json({
+            {"created", true},
+            {"name", json["name"]},
+            {"email", json["email"]}
+        }, http::http_response::status::created);
+    }).schema({
+        {"type", "object"},
+        {"required", {"name", "email"}},
+        {"properties", {
+            {"name",  {{"type", "string"}, {"minLength", 1}}},
+            {"email", {{"type", "string"}}},
+            {"age",   {{"type", "integer"}, {"minimum", 0}, {"maximum", 150}}}
+        }},
+        {"additionalProperties", false}
+    });
+
+    // PUT /api/users/:id - Update a user (partial update allowed)
+    server.put("/api/users/:id", [](http::request& req, nlohmann::json& json, http::response& res) {
+        res.json({
+            {"updated", true},
+            {"id", req["id"]},
+            {"fields", json}
+        });
+    }).schema({
+        {"type", "object"},
+        {"properties", {
+            {"name",  {{"type", "string"}, {"minLength", 1}}},
+            {"email", {{"type", "string"}}},
+            {"age",   {{"type", "integer"}, {"minimum", 0}}}
+        }}
+    });
+
+    // POST /api/orders - Nested object with enum validation
+    server.post("/api/orders", [](nlohmann::json& json, http::response& res) {
+        res.json({
+            {"order_id", "ORD-001"},
+            {"status", json["status"]},
+            {"items_count", json["items"].size()}
+        }, http::http_response::status::created);
+    }).schema({
+        {"type", "object"},
+        {"required", {"items", "status", "shipping"}},
+        {"properties", {
+            {"status", {
+                {"type", "string"},
+                {"enum", {"pending", "confirmed", "shipped"}}
+            }},
+            {"items", {
+                {"type", "array"},
+                {"minItems", 1},
+                {"items", {
+                    {"type", "object"},
+                    {"required", {"product", "quantity"}},
+                    {"properties", {
+                        {"product",  {{"type", "string"}}},
+                        {"quantity", {{"type", "integer"}, {"minimum", 1}}}
+                    }}
+                }}
+            }},
+            {"shipping", {
+                {"type", "object"},
+                {"required", {"city", "country"}},
+                {"properties", {
+                    {"city",    {{"type", "string"}}},
+                    {"country", {{"type", "string"}}},
+                    {"zip",     {{"type", "string"}}}
+                }}
+            }}
+        }}
+    });
+
+    // Endpoint without schema — accepts any JSON
+    server.post("/api/raw", [](nlohmann::json& json, http::response& res) {
+        res.json({{"received", true}, {"data", json}});
+    });
+
+    uint16_t port = 8090;
+    if (argc > 1) port = std::stoi(argv[1]);
+
+    std::cout << "Schema Validation Server starting on port " << port << std::endl;
+    std::cout << "\nTry these requests:\n" << std::endl;
+
+    std::cout << "# Valid user creation:" << std::endl;
+    std::cout << R"(curl -X POST http://localhost:)" << port
+              << R"(/api/users -H "Content-Type: application/json" -d '{"name":"Alice","email":"alice@example.com","age":30}')" << std::endl;
+
+    std::cout << "\n# Missing required field (returns 400):" << std::endl;
+    std::cout << R"(curl -X POST http://localhost:)" << port
+              << R"(/api/users -H "Content-Type: application/json" -d '{"name":"Alice"}')" << std::endl;
+
+    std::cout << "\n# Wrong type (returns 400):" << std::endl;
+    std::cout << R"(curl -X POST http://localhost:)" << port
+              << R"(/api/users -H "Content-Type: application/json" -d '{"name":123,"email":"test@test.com"}')" << std::endl;
+
+    std::cout << "\n# Valid order with nested objects:" << std::endl;
+    std::cout << R"(curl -X POST http://localhost:)" << port
+              << R"(/api/orders -H "Content-Type: application/json" -d '{"status":"pending","items":[{"product":"Widget","quantity":3}],"shipping":{"city":"Madrid","country":"Spain"}}')" << std::endl;
+
+    std::cout << std::endl;
+
+    server.start("0.0.0.0", port);
+    return 0;
+}