Zig HTTP 客户端与 REST 集成：std.http.Client 实战

var client: std.http.Client = .{ .allocator = allocator };
defer client.deinit();          // 关闭所有池中连接

const std = @import("std");

var body = std.ArrayList(u8).init(allocator);
defer body.deinit();

const res = try client.fetch(.{
    .location = .{ .url = "https://api.github.com/repos/ziglang/zig" },
    .response_storage = .{ .dynamic = &body },   // 动态缓冲，自动扩容
    .extra_headers = &.{
        .{ .name = "accept", .value = "application/vnd.github+json" },
        .{ .name = "user-agent", .value = "plumephp-demo/1.0" },
    },
});

std.debug.print("status={d} bytes={d}\n", .{ @intFromEnum(res.status), body.items.len });

var header_buf: [8 * 1024]u8 = undefined;
var req = try client.open(.GET, try std.Uri.parse(url), .{
    .server_header_buffer = &header_buf,   // 存响应头，生命周期须覆盖整个请求
});
defer req.deinit();
try req.send();     // 发送请求行与头部
try req.finish();   // 结束请求（GET 无 body）
try req.wait();     // 等待响应头到达

var chunk: [4096]u8 = undefined;
var reader = req.reader();
while (try reader.read(&chunk)) |n| {
    // 流式处理 chunk[0..n]，不必整块进内存
    _ = n;
}

const payload = "{\"model\":\"llama3\",\"prompt\":\"hi\"}";

var req = try client.open(.POST, try std.Uri.parse(endpoint), .{
    .server_header_buffer = &header_buf,
    .extra_headers = &.{
        .{ .name = "content-type", .value = "application/json" },
        .{ .name = "authorization", .value = auth_header },
    },
    .keep_alive = true,
});
defer req.deinit();
req.transfer_encoding = .{ .content_length = payload.len };  // 必须显式设置
try req.send();
try req.writeAll(payload);
try req.finish();
try req.wait();

try client.ca_bundle.rescan(allocator);        // 扫描系统证书目录（0.14 起）

const Repo = struct {
    name: []const u8,
    stargazers_count: u32,
    language: ?[]const u8 = null,   // 字段可能缺失
};

const parsed = try std.json.parseFromSlice(Repo, allocator, body.items, .{
    .ignore_unknown_fields = true,   // 忽略服务端新增字段
});
defer parsed.deinit();
const repo = parsed.value;

var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
const repo = try std.json.parseFromSliceLeaky(Repo, arena.allocator(), body.items, .{});
// repo.name 在 arena 存活期间一直有效

var out = std.ArrayList(u8).init(allocator);
defer out.deinit();
try std.json.stringify(Request{ .model = "llama3", .prompt = "hi" }, .{}, out.writer());
req.transfer_encoding = .{ .content_length = out.items.len };

pub const ApiClient = struct {
    allocator: std.mem.Allocator,
    http: std.http.Client,
    base_url: []const u8,
    token: ?[]const u8 = null,

    pub fn init(allocator: std.mem.Allocator, base_url: []const u8, token: ?[]const u8) !ApiClient {
        var self = ApiClient{ .allocator = allocator, .http = .{ .allocator = allocator }, .base_url = base_url, .token = token };
        try self.http.ca_bundle.rescan(allocator);
        self.http.connection_pool.max_conns_per_host = 8;
        return self;
    }

    pub fn deinit(self: *ApiClient) void {
        self.http.deinit();
    }

    /// 发一个 JSON 请求，响应解析为 std.json.Value（内存归 arena）
    pub fn call(self: *ApiClient, arena: std.mem.Allocator, method: std.http.Method, path: []const u8, payload: []const u8) !std.json.Parsed(std.json.Value) {
        const url = try std.fmt.allocPrint(arena, "{s}{s}", .{ self.base_url, path });
        var hb: [16 * 1024]u8 = undefined;
        var req = try self.http.open(method, try std.Uri.parse(url), .{
            .server_header_buffer = &hb,
            .extra_headers = &.{.{ .name = "content-type", .value = "application/json" }},
            .keep_alive = true,
        });
        defer req.deinit();
        if (payload.len > 0) req.transfer_encoding = .{ .content_length = payload.len };
        try req.send();
        if (payload.len > 0) try req.writeAll(payload);
        try req.finish();
        try req.wait();

        if (req.response.status.class() == .client_error) return error.ApiClientError;
        if (req.response.status.class() == .server_error) return error.ApiServerError;

        const raw = try req.reader().readAllAlloc(arena, 32 * 1024 * 1024);
        return std.json.parseFromSlice(std.json.Value, arena, raw, .{});
    }
};